Recursively calling a generic method with runtime parameters - C# Discussion Boards

17-Dec-07 9:23

If I have these classes...

public class TestClass
{
        //Properties etc.. to go here
}

public class TestCollection : List<TestClass>
{
}

... and I pass an instance of the TestCollection class to this...

public static void MyMethod(object ListObject)
{
}

... I can use reflection to get loads of info about the TestCollection (ListObject) class.

What I can't figure out is how to use reflection to get the <T> (in this case TestClass) as this is the class I need to know about the properties for.

Dave

modified on Monday, December 17, 2007 3:38:19 PM

Ed.Poore17-Dec-07 11:31

17-Dec-07 11:31

Hopefully this code will help you reflect on the problem (pun semi-intended):

using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;

namespace GenericReflection
{
	class Program
	{
		static void Main(string[] args)
		{
			List<int> intList = new List<int>();
			DisplayGenericInformation(intList);
		}

		static void DisplayGenericInformation(object genericObject)
		{
			DisplayGenericInformation(genericObject, 0);
		}
		static void DisplayGenericInformation(object genericObject, int indent)
		{
			Type genericObjectType = genericObject.GetType();
			WriteIndented(genericObjectType.Name, indent);
			foreach (Type argumentType in genericObjectType.GetGenericArguments())
			{
				WriteIndented(argumentType.Name, indent + 1);
				DisplayGenericInformation(argumentType, indent + 2);
			}
		}
		static void WriteIndented(string message, int indent)
		{
			while ((indent--) > 0)
			{
				Console.Write("  ");
			}
			Console.WriteLine(message);
		}
	}
}</int></int>

DaveyM6918-Dec-07 0:33

18-Dec-07 0:33

Thanks, it's helped a little but there is still a problem as commented in this ammended version of the code you supplied.

using System;
using System.Collections.Generic;
using System.Reflection;

namespace GenericReflection
{
    class Program
    {
        class MyClass
        { }

        class MyCollection : List<MyClass>
        { }

        static void Main(string[] args) 
        {
            //Works fine :-)
            List<MyClass> intList1 = new List<MyClass>();
            DisplayGenericInformation(intList1);

            Console.WriteLine(Environment.NewLine);

            //Doesn't work, just displays 'MyCollection'
            MyCollection intList2 = new MyCollection();
            DisplayGenericInformation(intList2);

            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Press any key to exit");
            Console.ReadKey();
        }

        static void DisplayGenericInformation(object genericObject)
        { 
            DisplayGenericInformation(genericObject, 0);
        }		
        
        static void DisplayGenericInformation(object genericObject, int indent)
        { 
            Type genericObjectType = genericObject.GetType();
            WriteIndented(genericObjectType.Name, indent);
            foreach (Type argumentType in genericObjectType.GetGenericArguments())
            { 
                WriteIndented(argumentType.Name, indent + 1); 
                DisplayGenericInformation(argumentType, indent + 2); 
            } 
        }		
        static void WriteIndented(string message, int indent) 
        { 
            while ((indent--) > 0) 
            { 
                Console.Write("  "); 
            } 
            Console.WriteLine(message);
        }
    }
}

Ed.Poore18-Dec-07 10:04

18-Dec-07 10:04

That makes sense because you'd need to look at the base type information for the classes. Since I don't really know what the structure of the code is like and what you're going to expect I can't provide a better example, but you could change it too something like:

using System;
using System.Collections.Generic;
using System.Reflection;

namespace GenericReflection
{
    class Program
    {
        class MyClass
        { }

        class MyCollection : List<myclass>
        { }

        static void Main(string[] args) 
        {
            //Works fine 
            List<myclass> intList1 = new List<myclass>();
            DisplayGenericInformation(intList1);

            Console.WriteLine(Environment.NewLine);

            //Doesn't work, just displays 'MyCollection'
            MyCollection intList2 = new MyCollection();
            DisplayGenericInformation(intList2);

            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Press any key to exit");
            Console.ReadKey();
        }

        static void DisplayGenericInformation(object genericObject)
        { 
            DisplayGenericInformation(genericObject, 0);
        }		
        
        static void DisplayGenericInformation(object genericObject, int indent)
        { 
            Type genericObjectType = genericObject.GetType();
            WriteIndented(genericObjectType.Name, indent);
            foreach (Type argumentType in genericObjectType.GetGenericArguments())
            { 
                WriteIndented(argumentType.Name, indent + 1); 
                DisplayGenericInformation(argumentType, indent + 2); 
                // Can't remember what the property / method is to access the base class but should be obvious
                WriteIndented("Base:" + argumentType.BaseClass.Name, indent + 1);
                DisplayGenericInformation(argumentType.BaseClass, indent + 2);
            } 
        }		
        static void WriteIndented(string message, int indent) 
        { 
            while ((indent--) > 0) 
            { 
                Console.Write("  "); 
            } 
            Console.WriteLine(message);
        }
    }
}</myclass></myclass></myclass>

DaveyM6918-Dec-07 11:18

18-Dec-07 11:18

Thanks for your efforts Ed.

If I explain what I'm trying to acheive it may make more sense!

In this application there are lots of individual classes eg.

public class Student
        {
            private int _ID;
            private string _Name;
            private DateTime _DOB;

            public int ID
            {
                get { return _ID; }
                set { _ID = value; }
            }

            public string Name
            {
                get { return _Name; }
                set { _Name = value; }
            }

            public DateTime DOB
            {
                get { return _DOB; }
                set { _DOB = value; }
            }
        }

Most of these also need a collection eg:

public class StudentCollection : List<student>;
        { }

I've been implementing the IComparer interface on the individual classes and doing recursive sorting on its properties using CompareTo but that means I have to write the CompareTo method for each individual class.

What I'm trying to do is to create a generic sorter method that accepts a collection object and recursively sorts it based upon the properties of the individual object that is contained in each index of the incoming object

public static void GenericCompare(object ListObject)
        {
            //Find individual object class
            //Iterate through properties to do recursive sort
        }

i hope this makes sense!

Ed.Poore18-Dec-07 14:23

18-Dec-07 14:23

It does make sense but you seem to have a slightly odd way of going about it.

Quick question are you restricted on framework versions / compiler versions, e.g. are you using 2.0, 3.0, 3.5 framework and which compilers: 2005 or 2008?

Second point is that I recommend you reading this[^] fantastic article on "code generation" which will speed up things considerably because you're going to be doing a lot of reflection your way.

I'm thinking about a semi-ideal solution at the moment...

Ed.Poore18-Dec-07 14:44

18-Dec-07 14:44

Ok I've whipped together a simple demo:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;

namespace ReflectionComparer
{
	internal static class Program
	{
		[STAThread]
		private static void Main(string[] args)
		{
			// Initialize data
			var students = new StudentCollection();
			var teachers = new TeacherCollection();
			students.AddRange(new Student[] {
				new Student() { ID = 1, Name = "Edward Poore", DOB = new DateTime(1988, 4, 7) },
				new Student() { ID = 2, Name = "Joe Smith", DOB = new DateTime(2001, 5, 6) },
				new Student() { ID = 3, Name = "Davey M69", DOB = new DateTime(2006, 11, 25) }
			});
			teachers.AddRange(new Teacher[] {
				new Teacher() { ID = 1, Name = "Eric Yeatman", DOB = new DateTime(1964, 10, 2), Department = "EEE" },
				new Teacher() { ID = 2, Name = "Chris Maunder", DOB = new DateTime(1972, 3, 19), Department = "CS" },
				new Teacher() { ID = 3, Name = "Marc Clifton", DOB = new DateTime(1984, 5, 1), Department = "BIOL" }
			});

			DisplayInformation(students);
			DisplayInformation(teachers);
		}

		private static void DisplayInformation(object collection)
		{
			// Extract the enumerable collection and the enumerator
			var list = (collection as IEnumerable);
			var enumerator = list.GetEnumerator();
			// If this list is empty then nothing needs to be done
			if (enumerator.MoveNext() == true)
			{
				Sort(list, enumerator.Current.GetType());
			}
		}
		private static void Sort(IEnumerable collection, Type objectType)
		{
			Console.WriteLine(objectType.Name);
			foreach (var property in objectType.GetProperties())
			{
				Console.WriteLine("  {0}", property.Name);
			}
		}
	}
}

Student, Teacher are simple classes which define ID, Name and DOB (Teacher also includes department). The collection classes all inherit from List>T<.

I'm sorry the code uses 3.5 syntax but it saves so much typing and is so elegant I can't resist using it, hopefully things are fairly clear. The one thing that is not clear from your examples is how you decide which properties to sort on. If it were a simple are they the same test then you would simply check all properties are equal but I don't understand how you decide which one takes preference over the other (unless you specify it to the sorter routine).

Re: Reflection with Generic Lists [modified]

DaveyM6919-Dec-07 0:39

19-Dec-07 0:39

Thanks Ed, this does exactly what I wanted.

I have no restriction on framework and I'm currently using 3.5.

Once I have the properties of the class (which your code gives me) the sort is pretty easy as the method will also be passed a parameter stating which property to begin at, a little error checking, then recursively sort from there to the end of the remaining properties and the job's done. This is assuming that the properties are always returned in the order they are defined in the class - I haven't found any documentation on this but it appears so from my experiments.

The article you linked to is FASCINATING! It looks like the way to go. It'll keep me busy over xmas I'm sure.

Once again, many thanks for all your time and help.

Edit: I can't vote on your last reply as there's something gone wrong in the formatting - I had this with my previous post and had to view the html source to get the hyperlink to use to be able to edit it.

I voted on your initial reply instead.

modified on Wednesday, December 19, 2007 6:47:10 AM

Ed.Poore19-Dec-07 4:23

19-Dec-07 4:23

If you want my full solution it's here[^].

Created with VC# 2008 (am waiting for Imperial to get VS2008 Pro through their campus agreement).

Just had another thought, you could use attributes to set the sort order of properties, if the attribute doesn't exist then don't sort. Something like:

[Sort(0, SortOrder.Ascending)]
public string Name { get; set; }

[Sort(1, SortOrder.Descending)]
public DateTime DOB { get; set; }

(Example uses automatic properties, a fantastic feature).

DaveyM69 wrote:
The article you linked to is FASCINATING! It looks like the way to go. It'll keep me busy over xmas I'm sure.

It certainly is, I experimented with it for a rewrite of a DAL that I wrote for a company I worked for but LINQ seems to have more or less knocked this method on the head. Although it would be a very cool way to go.

It's these kind of problems which I enjoy helping out in, what with my degree and so on I don't have that much time for programming and that which I do do has been in Pascal and Assembler for the course (although I don't do any extra-curricular stuff like my fellows since it's simply a change of framework and syntax). And god-forbid in the near future some Java, I was offered a job by one of my lecturers at Imperial (Software Engineering lecturer, originally from the Computer Science department but now lecturing for Electrical & Electronic Engineering) and this unfortunately is in Java Dead | X|

Ed.Poore19-Dec-07 13:19

19-Dec-07 13:19

A new and updated project[^] has been uploaded.

Sorry if it took the fun away from you but I needed something to relax ( Roll eyes | :rolleyes:

) my mind so continued with the Three Monkeys approach and have implemented the suggestions I made earlier. (I don't know whether this is possible in your case): but if you inherit your "data" class from ComparableObject then unless the CompareTo method is overridden it automatically compares itself through "reflection".

To allow this you tag each of your properties with a SortAttribute specifying the priority in which the properties are to be sorted, see code for examples. The method which builds the DynamicMethod looks for these attributes (using a Cool | :cool:

piece of LINQ, making it sooo much easier, and ordering them in order of the priority). It then basically goes through and generates the IL for making the comparison, as if you'd typed it out yourself.

These dynamic methods are stored in a Dictionary<TKey,TValue> so that subsequent calls don't hit the performance penalty of performing reflection.

Quite a handy piece of code actually, might write it up into an article...

[BTW]Thanks for providing me with something "challenging" to do in C#[/BTW]

DaveyM6920-Dec-07 0:04

20-Dec-07 0:04

Cool! Very cool actually. This is one of those things that initially you think 'why does he want to do that?', but the more you think about it, it makes sense.

The amount of times I've had to write custom comparers so I can sort on either one particular property or recursively sort on many, I figured there had to be a way of implementing a more Generic one.

I developed one that worked but you had to pass a string array containing the properties you wished to sort on. It just felt a bit clumsy as the properties were already defined in the class so why was I having to restate them?

Marvellous work.

Ed.Poore wrote:
[BTW]Thanks for providing me with something "challenging" to do in C#[/BTW]

- no problem Wink | ;)

Ed.Poore20-Dec-07 0:09

20-Dec-07 0:09

Well I've tidied the code up a bit and got it into article form, now just got to write the damn article...