I’ve recently been asked by one of our new dotNet developers whether it’s possible to cast your regular everyday .Net 1.x System.Collections.ArrayList or the like onto a generic System.Collections.Generic.List<T> . I have to admit, I seem to suffer from some kind of Obsessive-Compulsive Disorder when it comes to programming problems. I mean my original reaction is usually “Of course not, what kind of frivolous idea is that?“, but then I cannot go about without solving the problem. So it was this time.

There seems to be no pre-coded framework solution for the problem, you should iterate over the items instead.  

At first I thought we could make use of the the framework supported conversion of  List<T> into List<Y>through a somewhat awkward method in the List<T>

public List<TOutput> ConvertAll<TOutput> (
	Converter<T,TOutput> converter
)

which requires you to implement a delegate that will do the conversion for every item. One problem with this solution though is that it does something exactly oposite to what we needed. It exports rather than importing and it does so between two generic types. However, there is an easy enough way to add this functionality in and you will only need to code it once and you will probably want to place it in some kind of static utility class.

 public static void copyToGenericList<T>(IEnumerable list, IList<T> genericList)
{
    foreach (object o in list)
    {
        genericList.Add((T) o);
    }
}

With the help of this method you will copy any enumerable type into whatever generic list you may find. Granted the method is not doing any type checking and will fail in case of any type mismatch it may encounter, but you would want to know about it nonetheles, wouldn’t you? Simple try/catch it around will do the trick, either that or a simple modification: 

public static void copyToGenericListChecked<T>
    (IEnumerable list, IList<T> genericList)
{
    foreach (object o in list)
    {
        if (o is T)
        {
            genericList.Add((T)o);
        }
    }
}

Which however will fail silently if the objects in the original list are of a wrong type, which in turn makes using it quite dangerous.

The copying now becomes quite effortless:

//Create a non generic list of type in with some data in it
IList list = new ArrayList();
list.Add(456);
list.Add(123);
 
//our generic target
IList<int> intList = new List<int>();
 
//and the copy routine - completely effortless
SomeUtilClass.copyToGenericList(list, intList);

But better yet, why not simply create the list of the type you expect and populate its contents in one go from the non-generic? Sure:

public static List<T> convertToGenericList<T>(IEnumerable list)
{
    List<T> result = new List<T>();
    foreach (object o in list)
    {
        result.Add((T) o);
    }
    return result;
}

And the sample usage becomes exactly what we hoped for:

//Create a non generic list of type in with some data in it
IList list = new ArrayList();
list.Add(456);
list.Add(123);
 
//and the one line conversion - nice!
IList<int> intList2 = SomeUtilClass.convertToGenericList<int>(list);

Generics rule!

Posted in .Net Framework, C#, Software Development
1 Star2 Stars3 Stars4 Stars5 Stars (No Ratings Yet)
Loading...
| 2 Comments »

Google Maps control (property) for EPiServer

Since my effort towards making this control final has been somewhat limited lately, I’ve decided to simply release the code at its current stage so that others can play with it and perhaps we can have something decent done together. The control operation is described in my previous article therefore I will not be going much into it any longer. the deployment of it is something worth mention though…

Download the control form here. Extract the contents of the zip file to a folder and attach the project to your solution, make sure you have the proper EPiServer libraries referenced form the project or it may complain about the references being broken.

Once you have it compiling, copy the GoogleMapEditor.ascx, GoogleMapViewer.ascx and the contents of the resources folder to a folder named GoogleMap within your project folder. Also copy the contents of the lang folder to the lang folder of your site.

The controls the property instantiate try to be smart about resolving the location of its files, but the property does not know its location thus if you decide to place the scripts in a folder other than just GoogleMaps in the app main folder, you need to add to your web.config the following:

<add key="CogGoogleMapControlLocation" value="\GoogleMaps\" />

And in web.config you define the API keys for all the addresses the control will be available from as “CogGoogleMapApiKey_%HOSTNAME%” values.

e.g. set for my machine localhost (for me) & dune(for access from other computers within our network):

<add key="CogGoogleMapApiKey_localhost" value="A value generated for 'localhost'" />
<add key="CogGoogleMapApiKey_dune" value="A value generated for 'dune'" />

The controls determine by themselves which key to use based on the http request so that the Google API does not complain about the key being improper.

Other than this the control should be self registering and all you need to do is to add it to your Page Type in the Admin section of the site and add:

<EPiServer:Property ID="GoogleMapData" runat="server" PropertyName="GoogleMapData" />

to the template you want to use it with.

The control really needs an improved support for translation the stuff currently there is used for learning more that than to actually be useful. Should we decide to go further with it, it definitely will be extended.

The scripts used for the DOPE editing are released under GPL (the scripts were originally released with the MediaWiki GoogleMaps editor under the same license). Those scripts although modified slightly are also released under GPL and are NOT a part of the control – they just happen to be used by it. I am still trying to decide what license use with the rest of the control, so be aware that this is still a subject to be changed, for now just feel free to use the code and should you make any changes to it, please feed them back so that I can improve the control further. The control will most probably end up as a part of Epicode, as soon as I get a response on the epicode forums from Steve on how to add them.

To finalize my mini series on the object store I’d like to put a simple page comments library. The library takes care of everything that is required for you to post and retrieve a list of comments. It does not (so far) offer any moderation functionality or even facilitates any comments removal. It’s something that I will most probably be added in the process.

I am in the process of figuring out how I can contribute it through the Community EpiCode effort on CodeResort. As soon as I get some answers from Steve, I’ll get it uploaded there. In the mean time let me document how to start using it.

For the time being you can get the code here or the compiled library with the intellisense help form here.

Posting comments

the posting is somewhat manual in terms of not having a pre-made control for it. Which if you look at the code does not have much sense to have.

All you need to do is put two edit boxes on a page and a submit button, and then bind the action of the submit button to a code looking somewhat like:

protected void SubmitComment(object sender, System.EventArgs e)
{
    IPageComment newComment =
        PageCommentFactory.createInstance(Guid.Empty,
        string.Format("CommentForPage{0}", CurrentPage.PageLink.ID),
        CurrentPage.PageLink.ID,
        SubjectTextBox.Text, ContentTextBox.Text, DateTime.Now, false, true, false);
    newComment.Save();
}

I honestly don’t feel like making a custom control for creating those would be worthwhile since no one would end up using it anyway.

The listing of comments however…

The comments can be accessed in a number of ways.

Probably the easiest one would be by using the templated control I’ve written in the library, which is a simple descendant of the ASP.NET repeater. The page could would look something like:

...

<%@ Register TagPrefix="CognifideControls"
    Namespace="Cognifide.EPiServerControls.PageComments.Controls"
    Assembly="Cognifide.EPiServerControls.PageComments" %>

...


<CognifideControls:PageCommentsList ID="CommentControl" runat="server"
    PageLinkIdProperty="<%# CurrentPage.PageLink.ID %>">
    <ItemTemplate> 
        <b><%# CommentControl.CurrentComment.Title %></b> - 
        <%# CommentControl.CurrentComment.SubmitDate.ToString() %><br />
        <%# CommentControl.CurrentComment.Content%><br /><br />
    </ItemTemplate>
</CognifideControls:PageCommentsList>

I’ve chose this way since that’s pretty much the standard way of adding controls that are defined in Episerver and just generally ASP.Net.

But nothing stops you from accessing the comments directly,  and then filling in the data for the repeater yourself like:

<asp:Repeater ID="CurrentComments" runat="server" 
    OnItemDataBound="CurrentComments_ItemDataBound"> 
    <ItemTemplate>
        <b><asp:Label ID="CommentSubjectLabel" runat="server"></asp:Label></b><br />
        <asp:Label ID="CommentContentLabel" runat="server"></asp:Label><br /><br />
    </ItemTemplate>
</asp:Repeater>

And then in the code-behind

protected void Page_Load(object sender, EventArgs e)
{
    List<IPageComment> comments =
        PageCommentFactory.GetCommentsForPage(CurrentPage.PageLink.ID, 
        DateTime.MinValue, DateTime.MaxValue, true);
    CurrentComments.DataSource = comments;
    CurrentComments.DataBind();
}

protected void CurrentComments_ItemDataBound(object sender, RepeaterItemEventArgs e)
{
    IPageComment comment = (e.Item.DataItem as IPageComment);
    Label commentSubjectLabel = (Label)e.Item.FindControl("CommentSubjectLabel");
    if (comment != null)
    {
        commentSubjectLabel.Text = comment.Title;
    }
 
    Label commentContentLabel = (Label)e.Item.FindControl("CommentContentLabel");
    if (comment != null)
    {
        commentContentLabel.Text = comment.Content;
    }
}

That’s pretty much what my implementation does anyway.

I hope to be able to put it up on CodeResort soon so that we can see what else could be done. Additionally my library allows for replacing the persistence provider, which we will probably have implemented using nHibernate to test its speed versus the ObjectStore. Should you be interested in providing some help with this, or adding come moderation code to the admin side of the site on top of the interface, it would definitely be greatly appreciated.

I have started implementing the Property based on the code so that it can be easily displayed on the editor’s page, but for now, I’ll have to delay it since we’ve got some other stuff to do related to the project I’m currently working on.

Posted in ASP.NET, C#, Downloadable, EPiServer, Software Development, Web applications
1 Star2 Stars3 Stars4 Stars5 Stars (3 votes, average: 3.67 out of 5)
Loading...
| Leave a Comment »

EPiServer’s ObjectStore (Part 2)

I think we’re mostly finished investigating ObjectStore for now. In this article I’ll try to finish up on the apsects of using the Object store in a real life solution that is a basic Page comments. In my previous article concerning ObjectStore I have described a way of storing and retrieving an object from the Store, which is fine and dandy if we know exactly the object’s OD, for example if we reference it from a page. But what good is a store like that if we cannot search it for content? The problem we were trying to solve using ObjectStore was storing comments for ANY Episerver page without having to do anything to the page type. We might need that for the upcoming project so the discovery may prove useful since this is a really neat way of storing objects.

So the class that we are going to store needs to persists the following values:

namespace Cognifide.EPiServerTest.ObjectStore
{
    [Serializable, XmlInclude(typeof (PageCommentDO))]
    public class PageCommentDO : IItem, IPageComment
    {
        private object id;
        private string name;
        [Indexed(true)]
        private int pageId;
        private string title;
        private string content;
        [Indexed(true)]
        private DateTime submitDate;
        [Indexed(true)]
        private bool moderated;
        [Indexed(true)]
        private bool published = true;
        [Indexed(true)]
        private bool reported;
 
    }
}

 You might have noticed that contrary to what I did before this class has some of its fields tagged with [Indexed(true)] attribute. This is required by the store object if we ever want to query the store for the class using those fields as a filtering criteria. The page also implements the required IItem interface (although the properties required by the interface are not shown in the excerpt) as well as our internal IPageComment which is added there for the purpose of easy switching of implementations. We intend to implement it on both ObjectStore and using NHibernate to make sure we get the best performance possible out of our solution. This interface is to allow us to easily switch between the 2 implementations.

Back to the ObjectStore

 First we need to introduce a few new classes EPiServer uses for querying the Store. The namespace that scopes the querying consists of the following entities: 

namespace EPiServer.BaseLibrary.Search
{    
    public class BetweenExpression : IExpression;
    public class EqualExpression : IExpression;
    public sealed class Expression;
    public interface IExpression;
    public class Order;
    public class Query : IEnumerable;
}

The Query class is at the center of any search in the Store, let’s start with the samples right away. The saving is almost identical to the sample that I’ve shown in my previous article:

public void Save()
{
    ISession session = null;
    try
    {
        // check if there is a schema for the type, if not create it.
        if (Context.Repository.SchemaForType(GetType()) == null)
        {
            TypeSchemaBuilder.RegisterSchemaAndType("CognifidePageCommentsStorage", GetType());
        }
 
        // get a new session from the current context.
        session = Context.Repository.CreateSession();
 
        // wrap it in a transaction 
        session.BeginTransaction();
 
        // make sure the id has been defined.
        if (Id.Equals(Guid.Empty))
        {
            Id = Guid.NewGuid();
        }
 
        //persist
        session.Save(this);
        session.CommitTransaction();
    }
    catch (ElektroPostException exception)
    {
        // ... rollback the transaction and do some reporting
        if (session != null)
        {
            session.RollbackTransaction();
        }
        throw;
    }
    finally
    {
        if (session != null)
        {
            session.Close();
        }
    }
}

Really there is not much meat there. The interesting part comes in the object retrieval. Even though the Search namespace does not look like it offers much, you can still build a fairly fophisticated filter with it. following code retrieves comments for a specific PageLinkID. The comments can be filtered by date and since the call is used to retrieve the page for viewing, we probably only want the ones that are public (meaning they have not been removed by the comment moderator).

 

public static List<PageCommentDO> GetCommentsForPage(int pageId, 
    DateTime beforeDate, DateTime afterDate, bool includeOnlyPublished)
{
    ISession session = null;
 
    try
    {
        // make sure there is a schema to read from, otherwise there is no point
        if (Context.Repository.SchemaForType( typeof (PageCommentDO)) == null)
        {
            return null;
        }
 
        //acquire a session
        session = Context.Repository.CreateSession();
 
        //create the query 
        Query query = new Query(typeof (PageCommentDO));
 
        // we only want comments for a singler page 
        query.Add(Expression.Equal("pageId", pageId));
 
        // should we filter to only wshow comments from some set time period?
        // the following demonstrate how to request a value from within a range
        if ((beforeDate != DateTime.MinValue) ||
            ((afterDate != DateTime.MaxValue) && (afterDate != DateTime.MinValue)))
        {
            query.Add(
                Expression.Between("submitDate",
                                   (beforeDate != DateTime.MinValue) ? beforeDate : new DateTime(0x76c, 1, 1),
                                   ((afterDate != DateTime.MinValue) && (afterDate != DateTime.MaxValue))
                                       ? afterDate
                                       : new DateTime(0x834, 1, 1)));
        }
 
        // probably for a displayed page we will only want to show published comments
        if (includeOnlyPublished)
        {
            query.Add(Expression.Equal("published", true));
        }
 
        // order the comments by date/time so that we get the most recent first
        query.AddOrder(new Order("submitDate", true));
 
        IList list = session.ExecuteQueryObject(query);
        List<PageCommentDO> result = new List<PageCommentDO>(list.Count);
        foreach (object item in list)
        {
            result.Add((PageCommentDO) item);
        }
        return result;
    }
    catch (ElektroPostException ex)
    {
        // ... do some reporting
        throw;
    }
    finally
    {
        if (session != null)
        {
            session.Close();
        }
    }
}

You nahe to agree, this really IS neat. All you need to do now to place the comments on a page is a few lines of code to bind the data from the Store with a repeated of a kind, and a set of edit boxes with a submit button :)

This is basically how much code the submission and retrieval the comments comment take:

// Load the comments to a repeater
protected void Page_Load(object sender, EventArgs e)
{
        List<PageCommentDO> comments = 
            PageCommentDO.GetCommentsForPage(CurrentPage.PageLink.ID, DateTime.MinValue, DateTime.MaxValue);
        CurrentComments.DataSource = comments;
        CurrentComments.DataBind();
}
 
// Comment submission
protected void SubmitComment(object sender, System.EventArgs e)
{
    PageCommentDO newComment = new
        PageCommentDO(Guid.Empty,
        string.Format("CommentForPage{0}", CurrentPage.PageLink.ID),
        CurrentPage.PageLink.ID,
        SubjectTextBox.Text, ContentTextBox.Text, DateTime.Now, false, true, false);
    newComment.Save();
}
 
// the data binding for the labels
protected void CurrentComments_ItemDataBound(object sender, RepeaterItemEventArgs e)
{
    PageCommentDO comment = (e.Item.DataItem as PageCommentDO);
 
    Label commentSubjectLabel = (Label)e.Item.FindControl("CommentSubjectLabel");
    if (comment != null)
    {
        commentSubjectLabel.Text = comment.Title;
    }
 
    Label commentContentLabel = (Label)e.Item.FindControl("CommentContentLabel");
    if (comment != null)
    {
        commentContentLabel.Text = comment.Content;
    }
}

Short of having a control pre=built for you I cannot think of it being able to make it easier.

I will look into packing it into a nice control that we would be looking into contributing some time in the future and of course if there is actually a demand for it.

EpiServer on Vista

EPiServer developer-to-developer forum holds an article on how to make EPiServer 4.61 run on Vista. I suspect that EPiServer CMS (a.k.a. EPiServer 5) will not have any of the described problems, but in the mean time I’m happily hacking my EPiServer on my other machine as well.

I’ve managed most of the way before and had the server running here, but it was having all sorts of problems, which are all gone after applying the suggestions (especially in the second post).

Posted in EPiServer, Software Development, Vista
1 Star2 Stars3 Stars4 Stars5 Stars (No Ratings Yet)
Loading...
| Leave a Comment »