SimoneB's Blog : C#

CS2 - a personal source code search engine

simoneb — Thu, 13 Sep 2007 15:16:00 GMT

As I blogged some time ago I have been developing a source code search engine called CS2. I completed it lately and, although it's not as feature-rich as others - say, Koders Pro Edition - it works pretty fine and suites the needs of whomever needs to search through code stored on its machine. Actually, it's neither as heavy as Koders Pro as well, and plus it's free and open source.

It works as an ASP.NET 2.0 website and lets you request indexing folders and singular files, as well as search through them with a simple syntax. By default searches are performed in full-text fashion, but you can restrict queries on particular fields. The syntax is documented in the website. It's multithreaded so indexing and searches can occur at the same time.

It can be customized using the Properties.config file in the Configuration directory, by setting the folder where the files of the index are stored as well as the update interval. It's capable of automatically removing from the index files which no longer exist on the file system as well as update those which have been edited.

At the moment it can parse and index only C# source code but it's written upon Windsor inversion of control container and can be easily extended just by adding a new parser. If anyone's interested I will post about the complete process of adding a new parser.

To get started just download the zipped website from the project homepage and run it. Then type the path of a folder containing C# source code files on your machine in the corresponding input field and wait some time for the indexing process to complete (you won't see the progress since it occurs on another thread so that you can perform searches concurrently with indexing). Its duration depends upon the number of files to be parsed and indexed. Once indexing is complete updating the page shows the number of documents the index contains. Click on the link on the upper-right edge of the page to show the search syntax.

New SQLite provider for ELMAH

simoneb — Wed, 05 Sep 2007 22:05:00 GMT

I bet you know what ELMAH is, don't you? ELMAH stands for Error Logging Modules and Handlers, and its main and only purpose is to log exceptions occurring in ASP.NET web applications, within which it integrates with just a couple of entries in the Web.config file. It's got a lot of documentation and it's open source, so for any additional information check out its website.

Until yesterday it let you log exceptions in memory, on xml files and SQL Server, but a highly requested feature was to use SQLite as a backing store. Although I didn't know SQLite much it has a cool .NET wrapper published on Sourceforge which exposes its features to the managed world, so I took on the reported feature request and implemented it. SQLite doesn't offer all of the features provided by SQL Server, but it's almost completely SQL92 compliant so it has all that's needed, and much more.

So why to use SQLite instead of SQL Server or xml files? SQLite is a relational database engine, so it's much faster than xml files, and compared with SQL Server at the moment our tests didn't show any performance penalty; plus, it's free! Paging through about 15.000 stored exceptions via ELMAH user interface resulted to be lightning fast!

Since SQLite syntax isn't widely documented, if anyone's interested I will blog about it and the steps I went through to integrate it with ELMAH. Otherwise, the source code is available on ELMAH Subversion repository.

IoC with Windsor Container part IV live

simoneb — Thu, 30 Aug 2007 06:54:00 GMT

The fourth and last article of the series about IoC is online and available for reading here. Any feedback is welcome, and please rate the article! Each article links the other articles of the series so the reading should be straight from beginning to end.

IoC with Windsor Container part III live

simoneb — Sat, 11 Aug 2007 11:17:00 GMT

The third article of the series about IoC is online and available for reading here. Any feedback is welcome, and please rate the article!

IoC with Windsor Container part II live

simoneb — Tue, 31 Jul 2007 15:45:00 GMT

The second article of the series about IoC is online and available for reading here. Any feedback is welcome, and please rate the article!

IoC with Windsor Container on DotNetSlackers

simoneb — Tue, 24 Jul 2007 09:41:00 GMT

I've written a 4 parts article series about Inversion of Control and Dependency Injection; the first part is already online here, the following parts should be online soon. It's a comprehensive overview of most of the features offered by Castle Windsor Container, starting from the basics and on to more advanced topics.

I hope you'll enjoy, so feel free to leave feedback!

Indexing and searching source code with Lucene.Net

simoneb — Fri, 29 Jun 2007 13:09:00 GMT

During the past week I've been working on a university project for my course of Information Retrieval, and although the project proposal from the teacher was to implement an xml parsing application written in Java I thought I would put in use the skills I developed on my own with the .NET framework to implement something more useful.

My idea was to create a homemade source code indexing and search service, so I started fiddling with Lucene.Net, CastleProject, C# Parser and a couple other open source projects to see what I could come up with. There are already a lot of services which allows to search source code online, see Krugle, Google Code Search and Koders among others.

Well, of course I couldn't use one of them as my course project, so I started implementing my own. I called it CS2 - C Sharp Code Search, and its source code is available under the MIT license on its Google Project Hosting website. I think it's a good example of the usage of Lucene.Net and CastleProject's IoC container in a wanna be real life project.

At the moment only the indexing part is implemented and you can see it working launching the console application project contained in the solution. The index created is compatible with the Lucene family implementations, so it can be browsed using an application like Luke, until I implement the searching part.

At the moment the features it implements are indexing C# source code files by parsing them and retrieving information like class, method and property names so that they can be searched against, as well as full-text search. It is extensible by implementing parsers for other languages, I've built it to make it pretty straightforward. It remembers the files indexed and periodically checks for modifications or file deletions. The console project comes with a full logging mechanism which shows what the program is actually doing. It is highly configurable via configuration files, see App.config and the files in the Configuration directory, used mostly for Castle Windsor configuration.

Let me know what you think! I'll say more about it in the next weeks... and please, don't hand it to your Information Retrieval teachers until I've delivered it to mine ;)

How to sort a generic List

simoneb — Tue, 19 Jun 2007 23:19:00 GMT

After reading this post from Steven Smith I thought I should write something about it.

Sorting a generic List<T> is pretty straightforward if you know how to do it. With C# 2.0, anonymous methods come at hand, as well as the little known Comparison<T> delegate (check out this post for more information about this class as well as other useful classes new to C# 2.0).

Ok, let's suppose we have a product class (let me save some space by using C# 3.0 syntax).

class Product
{
    public int ProductID { get; set; }
    public string ProductName { get; set; }
    public decimal UnitPrice { get; set; }
}

When we have a list of products we may want to sort it on the ProductName property before displaying it to the user. This can be accomplished with the Sort method of the List<T> class, which defines several overloads. The most handy in this case is the Sort(Comparison<Product>) method and the result is easily achieved with a couple lines of code.

List<Product> products = new List<Product>();

products.Sort(delegate(Product p1, Product p2)
              {
                  return p1.ProductName.CompareTo(p2.ProductName);
              });

So far so good, but what if we need to sort our list in several places during the execution of our program? Do we have to write that code each time? Actually no, since we can use the parameterless Sort() method of our list class. What this method does is use the "default comparer" to sort the list. So what's this default comparer? It's the comparer that's automatically created if we implement the IComparable<T> interface. This way we can centralize the sorting logic into our class, and just call the parameterless Sort() method on it whenever we need it sorted on the ProductName property.

public class Product : IComparable<Product>
{
    [...]

    public int CompareTo(Product other)
    {
        return ProductName.CompareTo(other.ProductName);
    }
}

Ok, now what if we want to be able to sort it on the other two properties, ProductID and UnitPrice? Do we have to write an anonymous method each time as we did in the beginning? Of course no, since there's a useful trick which prevents us from needing to do that. We can define two static Comparer<Product> properties in our product class, and supply them as parameters to the Sort(Comparer<T>) method of our list whenever we need it sorted on something which is not the default sorting logic.

public class Product : IComparable<Product>
{
    [...]

    public static Comparison<Product> PriceComparison =
        delegate(Product p1, Product p2)
        {
            return p1.Price.CompareTo(p2.Price);
        };

    public static Comparison<Product> IDComparison =
        delegate(Product p1, Product p2)
        {
            return p1.ProductID.CompareTo(p2.ProductID);
        };

    [...]
}

Since they are static they can be used simply like so: products.Sort(Product.PriceComparison) or products.Sort(Product.IDComparison), which will respectively sort the list by price and id.

Below is the full code of the Product class.

public class Product : IComparable<Product>
{
    private int id;
    private string prodName;
    private decimal price;

    public static Comparison<Product> PriceComparison = delegate(Product p1, Product p2)
                                                        {
                                                            return p1.price.CompareTo(p2.price);
                                                        };

    public static Comparison<Product> IDComparison = delegate(Product p1, Product p2)
                                                     {
                                                         return p1.id.CompareTo(p2.id);
                                                     };

    public int ProductID
    {
        get { return id; }
        set { id = value; }
    }

    public string ProductName
    {
        get { return prodName; }
        set { prodName = value; }
    }

    public decimal UnitPrice
    {
        get { return price; }
        set { price = value; }
    }

    public Product(int id, string prodName, decimal price)
    {
        this.id = id;
        this.prodName = prodName;
        this.price = price;
    }

    #region IComparable<Product> Members

    public int CompareTo(Product other)
    {
        return ProductName.CompareTo(other.ProductName);
    }

    #endregion

    public override string ToString()
    {
        return string.Format("Id: {0} Name: {1} Price: {2}", id, prodName, price);
    }
}

Searching source code on Koders.com

simoneb — Mon, 21 May 2007 21:49:00 GMT

Lately Phil Haack has blogged about his new job at Koders.com. As far as I can see they provide a search engine for open source code and let people submit their repositories so that their code can be indexed.

I've developed some interest in code searching since I'm going to implement a code search engine for my Information Retrieval course here in Italy, and hope Phil will give me some ideas in his future blog posts about Koders. In fact, I'm going to use Lucene.NET for indexing the source files - which I think they are using, too - and maybe I can learn some good practices and get some tips from them.

Though it doesn't have a slick interface as Krugle, Koders provides a service for querying its engine from the web, returning the search results as RSS, so I thought I could write a wrapper on top of it. I've come up with a fluent interface query class based on strongly typed classes generated with the ASP.NET RSS Toolkit.

Koders service allows refining search results by programming language, license, logical placement of the code in the source file (class name, method name, interface name) and by file name.

In the wrapper I created the querying is a two-step process. First you need to create a KodersQuery class supplying the parameters of the search, then you use one of the strongly typed classes generated by the ASP.NET RSS Toolkit to load and parse the results:

KodersQuery q = new KodersQuery()
    .ProgrammingLanguage(ProgrammingLanguage.Csharp)
    .SearchTerms("Subtext");

KodersRss rss = KodersRss.Load(q);

The KodersRss class wraps the xml returned by the query and provides the items found via the KodersRss.Channel.Items property.

Given the profileration of LINQ to X implementations it would be cool to create such an API for search source code, either on Google Code Search or Koders, but I'm still waiting for the final bits of LINQ before to attempt doing it. In fact I've seen the source code of some LINQ to X libraries and it looks like they won't compile with Orcas if they were created with the May CTP.

At the moment the source code is on my svn repository.

When is a singleton not a singleton? Serialization!

simoneb — Thu, 03 May 2007 22:37:00 GMT

Some days ago I wrote about the issue of having multiple instances of a singleton class in the same AppDomain. As for the implementation I gave and as emerged from the feedback to the post, this can happen when that class is serialized and deserialized or when it is instantiated via reflection. This is the original implementation:

public sealed class Singleton
{
    private static readonly Singleton instance = new Singleton();

    // Private constructor to prevent external instantiation
    private Singleton()
    { }

    public static Singleton Instance
    {
        get { return instance; }
    }
}

In case of serialization, there's actually a workaround explicitly provided by the .NET framework. This consists in implementing the ISerializable interface to provide a custom serialization mechanism.

Upon serialization, the GetObjectData method of the ISerializable interface is called to get the custom data needed for serializing the object. These data is set by setting up an appropriate SerializationInfo object. What's needed is a way to instruct the formatter about the identity of the object to be serialized, so that when it's deserialized it will be a reference to the same object - which we need to be unique. This can be accomplished by using the SetType method of the SerializationInfo object passed as a parameter to the GetObjectData method.

public void GetObjectData(SerializationInfo info, StreamingContext context)
{
    info.SetType(...); // accepts a Type parameter
}

What's the type we need to supply to the SetType method? It's not typeof(Singleton) - no need to specify that though, it's implicit - because in that case, upon deserialization, a particular constructor that the class has to define is called. The following is the signature of the constructor called by default when deserializing a class which implements the ISerializable interface:

Singleton(SerializationInfo, StreamingContext);

If no type is set using the SerializationInfo.SetType method into the GetObjectData method (called upon serialization), the above constructor is called on deserialization to populate the object being deserialized with custom data. If such a constructor is not implemented a SerializationException exception is thrown.

We won't need to implement that constructor since we want to avoid instantiating the class, but instead we need to pass to the SerializationInfo.SetType method the type of a helper class capable of returning the right instance of our singleton class. Again, the framework provides an interface explicitly designed for this task, called IObjectReference.

namespace System.Runtime.Serialization
{
    public interface IObjectReference
    { 
        object GetRealObject(StreamingContext context);
    }
}

This interface lets you specify that the class implementing it doesn't create new objects, but instead returns a reference to another object. This is good for us, since we can implement this interface by returning, via the GetRealObject method, a reference to the singleton instance of the Singleton class, thus preventing the formatter from instantiating a new object during deserialization.

So our helper class ends up having an implementation like in the following code snippet:

[Serializable]
internal class SingletonSerializationHelper : IObjectReference
{
   public object GetRealObject(StreamingContext context)
   {
       return Singleton.Instance;
   }
}

Going back to the Singleton class, the original code now is edited to make use of the SingletonSerialization helper class:

[Serializable]
public class Singleton : ISerializable
{
    private static readonly Singleton instance = new Singleton();

    // Private constructor to prevent external instantiation
    private Singleton()
    { }

    public static Singleton Instance
    {
        get { return instance; }
    }

    public void GetObjectData(SerializationInfo info, StreamingContext context)
    {
        info.SetType(typeof(SingletonSerializationHelper));
    }
}

What this code does when an instance of the class is serialized and deserialized can be summarized as follows:

Upon serialization, the GetObjectData method of the Singleton class is called and the formatter is instructed that the type of the object being serialized is actually not Singleton, but instead SingletonSerializationHelper.
Upon deserialization, the formatter knows that it needs to instantiate an object of type SingletonSerializationHelper, this being a class implementing the IObjectReference interface. Therefore, instead of calling its constructor, the GetRealObjectMethod is called, and the right, singleton instance of the Singleton class is returned.

Again, note that if the SerializationInfo.SetType method wasn't called during serialization, when deserializing the formatter would have tried to call the overloaded constructor of the Singleton class, and if it wasn't provided a SerializationException exception would have been thrown. The reason why it isn't called upon deserialization is that we make the formatter believe that the type of the class it will have to deserialize is of type SingletonSerializationHelper in place of Singleton.

This example appears on the MSDN Library in a couple of pages about serialization, although I learned about this workaround when reading an old article written by Jeffrey Ritcher on the MSDN Magazine.

.NET interview question - when is a singleton not a singleton?

simoneb — Sun, 29 Apr 2007 20:14:00 GMT

I've read some posts lately with questions people use to ask or have been asked during a job interview, so I wanted to post a tricky question too.

I've talked about singletons in the past, and what we use to think is that a classic singleton class has to be unique into a specific AppDomain. Let's take this simple implementation of the singleton pattern, which is thread safe, too: [edit: made the class sealed to avoid confusion]

public sealed class Singleton
{
    private static readonly Singleton instance = new Singleton();

    // Private constructor to prevent external instantiation
    private Singleton()
    {}

    public static Singleton Instance
    {
        get { return instance; }
    }
}

There's at least one situation where you can find yourself having multiple instances of the singleton class in the same AppDomain, can you tell when?

The ASP.NET Singleton-per-Request pattern

simoneb — Mon, 21 Aug 2006 04:58:00 GMT

Lately I needed to have an instance of a class to be unique for a certain amount of time, that is, one instance only of that class should exist for that time interval in my app domain.
In these cases what comes to my mind is the Singleton Design Pattern, which imposes that one instance only of a class can be loaded into an app domain and is alive as long as the app domain is.
My problem was that I needed that object to be unique only for a small time interval, which later I identified as being the life of a single request. That's when I recalled of a very useful IDictionary collection whose lifetime corresponds to the request-response cycle, and where you can store items which are then available during all the stages of the pipeline. This object is the Items instance property of the HttpContext class, and is defined as following:

System.Collections.IDictionary HttpContext.Items

Let me say it again: into this collection you can store items that are then made available during all the request-response process, and are unique to that particular request-response. To enfore this and make it even clearer, the description of this object as given by the intellisense is:

Gets a key/value collection that can be used to organize and share data between
an System.Web.IHttpModule interface and an System.Web.IHttpHandler interface
during an HTTP request.

You understand how powerful this object is, and the ASP.NET engine uses this mechanism itself to mantain some state information, like the session id and something more.
Going back to my problem, what I wanted to achieve is a lazy load (created only when necessary) instance of a class being unique to my request, so I came up with this code.

public class SingletonPerRequest
{
    public static SingletonPerRequest Current
    {
        get
        {
            return (HttpContext.Current.Items["SingletonPerRequest"] ??
                (HttpContext.Current.Items["SingletonPerRequest"] = 
                new SingletonPerRequest())) as SingletonPerRequest;

        }
    }
}

which can be used calling the static Current property of the class. What this code does is check if an instance of the class is already in the Items collection. In that case, it returns a reference to that instance, otherwise a new instance is created and placed in the Items collection, so that the next time it is requested during this same request it's already there.
Note that here we don't need any synchronization mechanism, since a single request is not executed concurrently by more than one thread.

Managing collections with functors

simoneb — Sat, 19 Aug 2006 21:22:00 GMT

Functors are a cool feature of .NET 2.0 which ease the management of collections.
Patrick Smacchia, in the late 2004, has written an interesting article for TheServerSide which covers many topics, and functors too. The recent advent of Linq will perhaps make them obsolete - even before they become famous! - but it is a feature to be aware of anyway.
Let me guide those of you who don't have much familiarity with delegates and anonymous methods through the topic.
Let's suppose we have a class which describes a student (I won't use properties just to save some space):

public class Student
{
    public string name;
    public int age;
    public string course;

    public Student(string name, int age, string course)
    {
        this.name = name;
        this.age = age;
        this.course = course;
    }
}

Then we create a collection of students which represents an entire school and populate it with some students:

List<Student> school = new List<Student>();

school.Add(new Student("Bart", 14, "Science"));
school.Add(new Student("Lisa", 13, "Science"));
school.Add(new Student("Milhouse", 12, "Science"));
school.Add(new Student("Homer", 45, "Beer"));

After setting up the environment for testing functors, we are ready to go. Imagine we want to retrieve from our list only the students with certain characteristics, i.e. students which attend the science course, and put them inside another list. There are a couple of ways of doing that, and maybe the one which first comes to our mind is creating a method like the following:

// retrieves all the students of the science course
public static List<Student> GetScienceStudents(List<Student> allStudents)
{
    List<Student> scienceStudents = new List<Student>();

    foreach (Student student in allStudents)
        if (student.course == "Science")
            scienceStudents.Add(student);

    return scienceStudents;
}

which we can call in this way:

List<Student> scienceClass1 = GetScienceStudents(school);

As you can see, that's a lot of code for such a simple task, we can do better! If you play with the intellisense on the school list, you can see that there are some methods which accept strange parameters, in particular there's the following method which looks interesting in our case:

List<Student> List<Student>.FindAll(Predicate<Student> match)

It looks promising because it returns a list of students, that's exactly what we want. So, what's that Predicate<Student> that it accepts as a parameter? It's a delegate, that is, a pointer to a method, which defines the signature of the method. This delegate is new to C# 2.0, along with other three (which I will describe later):

public delegate void Action<T>(T obj);
public delegate TOutput Converter<TInput, TOutput>(TInput input);
public delegate int Comparison<T>(T x, T y);
public delegate bool Predicate<T>(T obj);

The Predicate<T> delegate
Let's focus on the Predicate<T> delegate, because once you understand this, the others are immediate. Since the method FindAll of our list accepts such a delegate, it means that it accepts any method with the same signature. So let's write a method faithful to that signature which returns true if the supplied student attends the science course:

// returns true if the student attends the science course
public static bool IsScienceStudent(Student student)
{
    return student.course == "Science";
}

Having this method, now we can call the FindAll method in this way:

List<Student> scienceClass2 = school.FindAll(new Predicate<Student>(IsScienceStudent));

Even in this case C# 2.0 makes our life easier because we don't need to create explicitly an instance of the Predicate delegate, but we can write the following, and the compiler takes care of doing that for us (in fact, the compiler emits the same code for both the previous and following method call):

List<Student> scienceClass3 = school.FindAll(IsScienceStudent);

Ok, that's something better compared to that first verbose method, but we still have to create a method just to retrieve the students of the science class.
Here come the C# 2.0 anonymous methods. Using this new feature, we don't even need to write the IsScienceStudent method, because we can supply its body directly when calling the FindAll method:

List<Student> scienceClass = 
    school.FindAll(delegate(Student student)
                   {
                       return student.course == "Science";
                   });

This is an anonymous method, because we are creating a method by supplying his body yet without giving it a name. I'm not delving here into the topic of anonymous methods, but it's interesting to see what is happening behind the scenes, that is, what the compiler does when we declare and use an anonymous method. Using an IL disassembler like Reflector helps very much during this task. Note that the names of the members generated by the compiler may vary and the members themselves are decorated with the CompilerGenerated attribute. I'm reporting here the exact output I got when disassembling the sample program I created:

A private static delegate object of type Predicate<Student> is created

[CompilerGenerated]
private static Predicate<Student> <>9__CachedAnonymousMethodDelegate4;

A private static method faithful to the signature imposed by the Predicate<Student> delegate is created (notice that this method is the same as the IsScienceStudent method we created before!)
```
[CompilerGenerated]
private static bool <Main>b__0(Student student)
{
      return (student.course == "Science");
}
```
During the execution of the program, a check is performed to see whether an instance of our delegate already exists, and in case it doesn't, a new one is created, pointing to the method created in the step above (that's why the compiler called it something like CachedAnonymousDelegate, because it's static and only one instance of it is created at runtime):
```
if (Program.<>9__CachedAnonymousMethodDelegate4 == null)
{
    Program.<>9__CachedAnonymousMethodDelegate4 = 
        new Predicate<Student>(Program.<Main>b__0);
}
```
Finally, the FindAll method is called supplying our cached anonymous delegate as a parameter:
```
List<Student> list5 = list1.FindAll(Program.<>9__CachedAnonymousMethodDelegate4);
```

As you can see, the compiler goes through all the steps we did before we knew about anonymous methods, thus giving us a great shortcut when writing code.

Going back to the primary topic, this is what functors are, they are parametric routines. In this case, the functor was the delegate instance created and used dinamically by the call to the FindAll method, which in turn parametrized it by calling it each time with a different input parameter, and not just in the case of an anonymous method, but even when we used the IsScienceStudent method.
As you can see, then, the Predicate<T> delegate is useful when we want to get a list of items which satisfy some conditions.

Now that you've assimilated the notion of functor we can see how the other delegates anticipated before can be useful. I won't show it from scratch using a method and then a delegate, but I will go directly to the point using anonymous methods.

The Action<T> delegate
This class is useful when you want to perform some task on all the items of the collection. Thus, le'ts suppose that, once obtained the students of the science course using one of the approaches described before, we want to change the name of the course for each of them, because the next year the science course will be called "Natural Science". Using an anonymous method with the Action<T> delegate signature this can be done using the ForEach method of our list:

scienceClass.ForEach(delegate(Student student) 
                      { 
                          student.course = "Natural Science"; 
                      });

After invoking this method all the students contained in the scienceClass list will have the course field equal to "Natural Science".

The Comparison<T> delegate
This delegate class is useful when we want to compare two objects of the same type, and in particular when the comparison is a custom comparison, that is, on a complex type like a class. This delegate can be used for sorting operations. In fact, the List<T> class exposes a method called Sort which accepts, among others, an instance of the Comparison<T> delegate. Thus, let's suppose that we want to sort the students of the natural science class based on the age (in ascending order); we can write the following code:

scienceClass.Sort(delegate(Student s1, Student s2) 
                   { return s1.age - s2.age; });

After this operation, the scienceClass list will contain the students sorted by ascending age.

The Converter<TInput, TOutput> delegate
This last delegate class is useful when we want to obtain a list of items of type TOutput from a list of items of type TInput. In our case, let's suppose that we want to obtain the list of the names of the students attending our famous natural science course. The TInput type will be the Student class, because we provide a list of students, and the TOutput type will be the string type, because we want in return a list of names. The method of the List<T> collection which is useful in this case is the ConvertAll method, which in fact accepts a Converter delegate:

List<string> names = 
    scienceClass.ConvertAll<string>(delegate(Student student)
                                     {
                                         return student.name;
                                     });

Conclusion
At the end of the post you can find a zipped sample console application I've created while writing this post.
As a side note, you must be aware that only the List<T> and Array classes expose methods which accept these delegates as parameters.
I hope this was useful and interesting. That said, for further investigation and for the complete list of methods which accept these delegates I point you to the article (which has lately become an entire chapter on his recent book) by Patrick Smacchia.

Lookup a control at an arbitrary level of the Page hierarchy

simoneb — Mon, 03 Jul 2006 16:45:00 GMT

In ASP.NET 2.0 the page hierarchy often happens to be deeper than it was with the older version, mostly when using MasterPages. Consequently, when you want to obtain a reference to a control of the page given its ID and you don't know at which level of the hierarchy it is placed, using the FindControl() method of the Page object isn't the right way of proceding since it just performs a search among the direct children of the page itself.

In such cases you may use a recursive search, which walks all the page hierarchy. Note that you should use this workaround only when you strictly need it, because it could introduce a consistent overhead in the processing of the page due to the fact that everything becomes a control when on the server, and you'll find yourself looping through a considerable number of controls. This is a recursive implementation of the method:

public static Control FindControl(string controlId, ControlCollection controls)
{
      foreach (Control control in controls)
      {
            if(control.ID == controlId)
                  return control;

            if(control.HasControls())
            {
                  Control nestedControl = FindControl(controlId, control.Controls);

                  if(nestedControl != null)
                        return nestedControl;
            }
      }
      return null;
}

Then you can simply use it this way:

Control foundControl = FindControl(controlToFindID, Page.Controls);

Template merging with NVelocity and ASP.NET

simoneb — Mon, 03 Jul 2006 15:46:00 GMT

Some time ago I wrote an article for CodeProject about merging templates with NVelocity.

For those who don't know what template merging means, think about a newsletter management system which needs to send emails to website users.
Website admins may need to customize the messages according to user info, that is, greeting the user with a "Hello [username]" or something like that, and have message templates easy to mantain, maybe keeping them on the file system as html pages or creating them dinamically in the code of the application.

How would you do this by hand? Don't think too much, use NVelocity!

In the article I develop a library which greatly eases the use of NVelocity in ASP.NET applications, as well as in any other type of .NET projects.

You can read the article as well as download source code and demo files here: Template merging with NVelocity and ASP.NET