Requirement:

I need to create a method to which user will pass:

1) a collection (Can be ArrayList or HashTable or DataTable or Generic List or Array)
2) Items to be removed from this collection
3) [Optional] PropertyName or ColumnName representing the value in 2) above. I think it is required for custom objects and data tables only.

In order to resolve this I am following approach mentioned below. Is it a good approach or is there a better way to do this?

Pseudocode

1) Create a function taking above inputs (Object, string, string)
2) Create overloaded 3 functions with same parameters as above but having collection argument as IList (to handle arrays etc.), IDictionary (to handle HashTables) and ComoponentData.IListSource (to handle datatables)
3) From method in 1) invoke the method in 2) and automatically the right overloaded method will get called

Code - Approach Followed

A similar example having a method to which any type of collection is passed and it returns count of collection.

'Method called with parameter as Object
Public Function GetCount(ByVal x As Object)
        If (GetType(IList)).IsAssignableFrom(x.GetType) Then
            Return GetCount1(CType(x, IList))
        ElseIf (GetType(IDictionary)).IsAssignableFrom(x.GetType) Then
            Return GetCount1(CType(x, IDictionary))
        Else
            Return GetCount1(CType(x, ComponentModel.IListSource))
        End If
    End Function


'Three implementations of count
    Public Function GetCount1(ByVal list As IList) As Integer
        Return list.Count
    End Function


    Public Function GetCount1(ByVal list As IDictionary) As Integer
        Return list.Count
    End Function

    Public Function GetCount1(ByVal list As ComponentModel.IListSource) As Integer
        Return list.GetList().Count
    End Function

You may be able to do this with extension methods if all of your collections implement the IEnumerable interface. Something along the lines of....

    public static class CollectionExtensionMethods
    {
        public static void RemoveCollection<T>(this IEnumerable<T> collection, IEnumerable<T> itemsToRemove)
        {
            collection.RemoveCollection(itemsToRemove);
        }
    }

Then you could use it like so:

            List<String> strings = new List<String>();
            strings.Add("aaaa");
            strings.Add("bbbb");
            strings.Add("cccc");

            List<String> stringsToRemove = new List<String>();            
            strings.Add("bbbb");

            strings.RemoveCollection<String>(stringsToRemove);


            HashSet<String> stringsHash = new HashSet<String>();
            stringsHash.Add("aaaa");
            stringsHash.Add("bbbb");
            stringsHash.Add("cccc");

            stringsHash.RemoveCollection<String>(stringsToRemove);

I haven't tested this but it might be worth a look.

Let me know if you need any more help

Scott

Based on the code example you provided, the only main suggestion I have is to change the (3) GetCount1 methods to be marked 'Private' instead of Public.  That way you can direct all traffic to the main GetCount method and control how the return and logic is processed without having someone sidestep your main entry point.

This to me seems a bit analgous to a Factory pattern where you can pass some parameters to a Factory method, and based on the parameters you get the appropriate object type returned from the Factory.  In your case you are not returning objects from a Factory method, but you are determining what is returned by calling the appropriate method based on the object type.