Dynamic Work Item Rss Feed

COMMENTED FEATURE: Allow sorting on object graph public properties

ngruson — Thu, 29 Nov 2007 13:02:03 GMT

I made some changes to the code to support this requirement and it works for me. You can get it at http://nils-gruson.blogspot.com/. Marc, can you take a look at this?

Greets,
Nils Gruson

CREATED ISSUE: Add support for automatic generation of Equals method and GetHashCode method

IDisposable — Wed, 28 Nov 2007 00:00:56 GMT

Per the best-practice documented [url]http://musingmarc.blogspot.com/2007/08/vtos-rtos-and-gethashcode-oh-my.html[/url] it would be cool to generate static proxy objects that do the comparison/ hash code computation base on all the fields/properties (possibly only value-types or all, or those flagged with an attribute). This would greatly reduce the amount of busy-work code while handling all the rules of GetHashCode.

CREATED ISSUE: Add support for interfaces

IDisposable — Tue, 27 Nov 2007 23:55:05 GMT

[From email]
While I was experimenting with the DynamicComparer<T> class, I noticed that it works beautifully where T is a class. When I tried to use an interface for T instead of a class, I get an exception on line 62 of DynamicComparer.cs.

My thought is that the interface describes what a class must support, so why wouldn't an interface work just as well? Though, I'm not sure how the interface would affect code generation...should it?

Let me give you an example to help highlight. The example works with a file system (files and folders). In short, I want to optimally layout, using the minimum number of media (CD, DVD), all files and folders the user has selected. For me, even the size of folders is just as important as file size -- hence the abstraction to IItem (see below). Note: Your class works even in .NET 3.5!! The example is a little longer than I had hoped, but I think it conveys the purpose in the Main() method right up front. Everything below that is just support.

static class Program
{
static void Main()
{
DirectoryInfo dir = new DirectoryInfo( @"C:\Users\Rob\Documents\Projects" );
FolderItem compilation = new FolderItem( dir ); // recursively builds a list of files and subfolders

// get ready for Bin Packing problem
List<IItem> list = new List<IItem>();
AddCompilationToList( list, compilation ); // I do not show an implementation for this method as it is trivial

// Of course, the UI may just want to sort by Size or by Name or by Location
// But, this is what I'd like to do to sort files AND folders by their size (descending), then location, then name
// This sort is needed when implementing the Bin Packing algorithm using First, Worst, or Best Item approaches
DynamicComparer<IItem> comparer = new DynamicComparer<IItem>( "Size DESC, Location, Name" );
list.Sort( comparer.Comparer );

// now do one of the Bin Packing algorithms -- not shown for space
}
}

interface IItem : IComparable<IItem>, IEquatable<IItem>
{
IContainerItem Parent { get; }
string Name { get; }
string Location { get; }
long Size { get; }
}

interface IContainerItem : IItem
{
ItemCollection Items { get; }
IEnumerable<FileItem> Files { get; }
IEnumerable<IContainerItem> Folders { get; }
}

class FileItem : IItem
{
FileInfo _file;

public FileItem( FileInfo file )
{
_file = file;
}

public string Name
{
get { return _file.Name; }
}

public string Location
{
get { return _file.DirectoryName; }
}

public long Size
{
get { return _file.Length; }
}
}

class FolderItem : IContainerItem
{
DirectoryInfo _dir;
long _size;

public FolderItem( DirectoryInfo dir )
{
_dir = dir;
BuildTree();
}

public string Name
{
get { return _dir.Name; }
}

public string Location
{
get { return _dir.FullName; }
}

public long Size
{
get { return _size; }
}

public ItemCollection Items
{
get { return _items; }
}

public IEnumerable<FileItem> Files
{
// Use LINQ to pull out only file from the ItemCollection
get { return (from item in Items where item is FileItem select item as FileItem).AsEnumerable<FileItem>(); }
}

public IEnumerable<IContainerItem> Folders
{
// Use LINQ to pull out only folders (containers) from the ItemCollection
// I have other types of IContainerItems which is why I don't return FolderItem
get { return ( from item in Items
where item is IContainerItem
select item as IContainerItem).AsEnumerable<IContainerItem>(); }
}

private void BuildTree()
{
// use dir.GetFiles() and dir.GetDirectories() and convert each to FileItem and FolderItem respectively
// recursively drill down each folder in dir.GetDirectories()
}

CLOSED ISSUE: Eliminate MethodAccessException for classes derived from generics

IDisposable — Fri, 25 May 2007 20:08:31 GMT

EmitCall doesn't always generate legitimate methods if the method is implemented on a base class that is generic. Change the DynamicEmit helper class to only use EmitCall for VarArgs methods and use general Emit for all others. Per this: Hi. I found the solution. I changed Call method in DynamicEmit class to this: public void Call(MethodInfo method) { if (method.IsFinal || !method.IsVirtual) { _ilGen.Emit(OpCodes.Call, method); } else { _ilGen.Emit(OpCodes.Callvirt, method); } } Now everything works fine. According to this http://blogs.msdn.com/haibo_luo/archive/2006/08/13/698719.aspx EmitCall is mainly for varargs methods and you can (should) use Emit when you do not use varargs. I do not understand MSIL but I might be a bug in EmitCall or I don't know. Have a nice day. Vlado

CREATED ISSUE: Eliminate MethodAccessException for classes derived from generics

IDisposable — Fri, 25 May 2007 19:44:29 GMT

Hi. I found the solution. I changed Call method in DynamicEmit class to this: public void Call(MethodInfo method) { if (method.IsFinal || !method.IsVirtual) { _ilGen.Emit(OpCodes.Call, method); } else { _ilGen.Emit(OpCodes.Callvirt, method); } } Now everything works fine. According to this http://blogs.msdn.com/haibo_luo/archive/2006/08/13/698719.aspx EmitCall is mainly for varargs methods and you can (should) use Emit when you do not use varargs. I do not understand MSIL but I might be a bug in EmitCall or I don't know. Have a nice day. Vlado

COMMENTED FEATURE: Allow sorting on object graph public properties

chrisgraham — Sun, 14 Jan 2007 09:02:39 GMT

This would be a great feature to have, are there any plans to add this in the future?

COMMENTED FEATURE: Allow sorting on object graph public properties

IDisposable — Wed, 27 Dec 2006 18:02:23 GMT

It would be helpful if there were a simple way to sort objects deeper in the object graph via their public properties. An Example Scenario: Parent object has children objects with property of Firstname The ability to specify an orderby (or alternative means) to sort by Parent.Child.Firstname (where Firstname is a public property of Child object) Comments: This is an excellent idea, but there are some snags possible. The bindings to the methods will, by necessity, be based on the declared return types of the properties involved. This may affect what end-result property is called.

CREATED FEATURE: Allow sorting on object graph public properties

jafin — Tue, 12 Dec 2006 23:11:13 GMT

CLOSED ISSUE: Add helper to ParameterCountMismatchException class to reduce code size

IDisposable — Fri, 03 Nov 2006 10:46:28 GMT

Extract the code that actually compares the parameter count and throws an exception into a helper method within ParameterCountMismatchException. This will reduce the size of the generated wrappers for the Params-type methods. This should improve the quality of the JIT code, and thus performance. Comments: Completed in 2.5.0.0

CLOSED TASK: Improve XML Documentation

IDisposable — Fri, 03 Nov 2006 10:46:15 GMT

Add XML documentation to all public members of the Dynamic class. Comments: Completed in 2.5.0.0

CLOSED TASK: Refactor to remove redundant code.

IDisposable — Fri, 03 Nov 2006 10:46:03 GMT

Several bits of the actual Builder's Emit logic is duplicated between Constructor and Method and also between Params and Explicit paths. Refactor those methods out to reduce the amount of code, and reduce the memory footprint of the class itself. Comments: Completed in 2.5.0.0

REOPENED ISSUE: Add helper to ParameterCountMismatchException class to reduce code size

IDisposable — Fri, 03 Nov 2006 10:45:51 GMT

CLOSED ISSUE: Add helper to ParameterCountMismatchException class to reduce code size

IDisposable — Fri, 03 Nov 2006 10:45:48 GMT

CREATED ISSUE: Add helper to ParameterCountMismatchException class to reduce code size

IDisposable — Fri, 03 Nov 2006 10:45:20 GMT

CREATED TASK: Refactor to remove redundant code.

IDisposable — Fri, 03 Nov 2006 10:42:33 GMT

CREATED TASK: Improve XML Documentation

IDisposable — Fri, 03 Nov 2006 10:40:35 GMT

Add XML documentation to all public members of the Dynamic class.

CREATED ISSUE: Add AccessorCache/

IDisposable — Fri, 29 Sep 2006 20:02:03 GMT

Integrate AccessorCache into the Dynamic library to handle caching of generated delegates for field or memeber accesses. The AccessorCache is cached against a type (via automatic generic specialization of the .Net runtime) usingt the member name (field/property). It will automatically search for matching members and generate a suitable delegate for either setting or getting a field or property value. The cached delegate is typesafe, but also can handle boxed values.