Develop Reference

C# Converting an anonymous object with nested collection into an IEnumerable - preferably using the 'as' keyword

My code receives an anonymous object created by another method. I would like to access and iterate through the nested collection in this object. I was trying to come up with several different ways to cast it using the 'as' keyword but no avail.
Here is the code which creates the object:
var result = new object();
foreach (var item in items)
{
result = new
{
Variants = item.Value.Select(m => m.Item2).GroupBy(n => n.Item1).Select(r => new
{
Name = r.Key,
Items = r.Select(p => new
{
Value = p.Item2.Trim(),
Text = p.Item2.Substring(0, p.Item2.LastIndexOf('_')).Trim()
}).Where(p => !string.IsNullOrEmpty(p.Text)).ToList()
})
};
}
Visual Studio gives me the following signature when I hover over the variable which received this anonymous type:
{ Variants = {System.Linq.Enumerable.WhereSelectEnumerableIterator<System.Linq.IGrouping<string, System.Tuple<string, string>>, <>f__AnonymousType1<string, System.Collections.Generic.List<<>f__AnonymousType2<string, string>>>>} }
In short: I would like to access the Text fields of the collection.
Here is the QuickWatch window showing the structure and data of this object:
QuickWatch Window
Would appreciate any help!
PS: Cannot change the code in the sending method.

If you don't have a static type of a class you can't cast to it. For anonymous types having its type means you either have it locally in the method or get as parameter of a generic method - neither is the case here.
You options are really limited to some sort of reflection to dig into anonymous class. The easiest way would be to let runtime deal with reflection by relying on dynamic like ((dynamic)myVariable).Text.

Having trouble accessing properties on IronPython class from C#

I have some C# code that instantiates an IronPython class and runs some code from it. The IronPython class in question implements an interface that was defined in C#. It also defines some of its own properties.
I am having trouble accessing the properties that are defined by the class itself, and I was wondering if anyone knew how to do this?
Here is an example IronPython class:
import clr
clr.AddReference('System.Core')
from System import Tuple
class TestClass (ITestInterface):
ExamplePropertyOne = System.Tuple[System.String, System.String]("Hello", "World!")
def ExampleMethod(self, some_parameter):
...code...
I create a ScriptEngine object to use the IronPython class, like so:
Dictionary<string, object> options = new Dictionary<string, object>();
options["Debug"] = true;
var python_script_engine = Python.CreateEngine(options);
var python_script_scope = python_script_engine.CreateScope();
python_script_engine.ExecuteFile("my_python_class.py", python_script_scope);
//The class could have any name, so instead of requesting the class by name,
//I simply iterate through the items in the python file to find the items
//that implements the expected interface, like so:
var python_script_items = python_script_scope.GetItems();
python_script_items = python_script_items.Where(x => x.Value is IronPython.Runtime.Types.PythonType);
foreach (var item in python_script_items)
{
System.Type item_type = (Type)item.Value;
var implemented_interfaces = item_type.GetInterfaces();
if (implemented_interfaces != null && implemented_interfaces.Length > 0)
{
if (implemented_interfaces.ToList().Contains(typeof(ITestInterface)))
{
var class_to_instantiate = item.Value;
var class_instance = class_to_instantiate();
...code here to get properties of class...
}
}
}
Just as an FYI, in the foreach loop "item" is a KeyValuePair (a string is the key and a dynamic object is the value). After iterating over many items, the if-statements succeed when we reach the correct key-value pair at which the key is "TestClass" (I've stepped through the code to make sure the if-statement is succeeding at the proper item).
Unfortunately, although we enter the if-statements with "TestClass" as the item's key, when I instantiate the class I don't seem to be able to view the properties that are declared on TestClass. I can only see the methods that are implemented from ITestInterface.
I have tried the following, not knowing which would get me the correct result:
var list1 = Dynamic.GetMemberNames(class_instance); //Using Dinamitey
var list2 = python_script_engine.Operations.GetMemberNames(class_instance);
var fields = item_type.GetFields();
var properties = item_type.GetProperties();
var attributes = item_type.CustomAttributes;
var attributes2 = item_type.GetCustomAttributes(false);
var members = item_type.GetMembers();
var var_names = python_script_scope.GetVariableNames();
None of the above return the property "ExamplePropertyOne" in their results, which is a member of "TestClass". I can only see the implemented methods. And of course the python_script_scope.GetVariableNames only returns info from the scope outside of the instantiated class.
So, any advice? Why am I only able to see the interface members? How can I access the class's properties?
Thanks for any help!

How can I pass a type, rather than an instance, to a function in C#?

I am attempting to use reflection to enumerate class fields and methods in order to do some automation in a web application. I am also abstracting this so that I could pass in any class.
Is there a way I could somehow pass in the type directly to a function to enumerate on rather than an instance of the type?
I would like the caller side to look like this:
var m = new MyClass(AClassOfSomeTypeIDefined);
I would like to avoid creating an instance as that is misleading to anyone who might use the class (as the instance isn't directly used).

using System;
public void UseType(Type t) {
// do something with t using reflection techniques - e.g.
Console.WriteLine("compat with int? {0}", typeof(int).IsAssignableFrom(t));
}
Call it with C# typeof keyword and the data type you want to pass.
// Examples...
UseType( typeof(int) );
UseType( typeof(System.Int32) );
UseType( typeof(System.Windows.Controls.Button) );
UseType( typeof(IDisposable) );
UseType( typeof(WhateverTypeYouWant) );
System.Type is one of the cornerstones of reflection as you already know, so run with it.
Other notes
Depending on what you want to do with the type, the following peripheral details might be useful.
To create an instance of a Type at runtime without having used the new keyword at compile time, use the System.Activator class. e.g.
// Create a List of strings like: new List<string>();
var list = (List<string>) Activator.CreateInstance( typeof(List<string>) );

yes just use the Type of your class. There's two basic ways to get the type:
Foo foo = new Foo();
Type myType = foo.GetType();
Type myTyp2 = typeof(Foo);
You can use GetType() if you only know the type at runtime (more common with reflection), or typeof() if you know the type at compile time already.
In your example this would be i.e.
var m = new MyClass(typeof(Foo));

You can pass a Type object just like any other parameter.
class MyClass
{
public MyClass(Type yourType)
{
// do as you please with yourType
}
}
The call it:
var m = new MyClass(typeof(YourType));

Declaring an object which can be of any Type in c#

I am looking for an implementation similar to the type 'id' in objective c which can be of any type during runtime.Is it possible to do that in c#?
let me explain my requirement
id abc;// a common type which can hold any object during runtime
if(cond1)
{
Option1 opt1 = new Option1();//opt1 is an object of user defined class Option1
abc = opt1;
}
else if(cond2)
{
Option2 opt2 = new Option2();
abc = opt2;
}
...
How can I do the same in c# ?
Thanks,
Nikil.

You can do this in two ways:
First, you can declare the type as object. This will allow you to assign anything to the type. Do be aware, however, that if you assign a value type to the object reference, it will be boxed.
For example:
object abc;
if(cond1)
{
Option1 opt1 = new Option1();//opt1 is an object of user defined class Option1
// Assignment works, but you can't call a method or prop. defined on Option1
abc = opt1;
} // ...
The second option, which requires C# 4, is to declare it as dynamic. This will allow you to actually call methods and properties on the object as if it were the "real" type. The method call will fail at runtime if it does not exist, but succeed at compile time.
For example:
dynamic abc;
if(cond1)
{
Option1 opt1 = new Option1();//opt1 is an object of user defined class Option1
// Assignment works
abc = opt1;
// This will work if Option1 has a method Option1Method()!
// If not, it will raise an exception at run time...
abc.Option1Method();
} // ...

dynamic types are exactly for this purpose. Their "type" is dynamic(which obviously means at run-time).
I don't know about objective-C but it seems like id = dynamic.
Essentially a dynamic type is treated as a "typeless" object. There is no intellisense and no type checking done at compile time.

object abc; // :-)
or is it too simple?

You have several choices to consider and var isn't one of them.
1) Make all you Option classes inherit from an abstract base class.
2) Make all your Option classes inherit from an Interface.
3) Use object as the type
4) Use a dynamic object
It depends on what you want to do with 'abc' after this point in the code.

Declare an object or use the dynamic keyword as others say, or if you know an interface or base class that all your possible objects derive from, use that type:
IOption abc;

Select new object as a parameter while preserving it's run-time-generated type

Consider the following:
// select a subset of the DataTable
var subset = DataTable.Where(...).Select(row => new
{
Id = Convert.ToInt32(row["Id"]),
Name = row["Name"].ToString(),
Email = row["Email"].ToString()
});
// or create a new object
var subset = new {
Id = 1,
Name = "something random",
Email = "name#domain.tld"
};
Is there any way to use the subset variable as a parameter to a method, without it being cast as a plain Object? Can you somehow carry the auto-generated type of the variable?
I am trying to avoid having to create new classes every time I want to pass LINQ subsets to methods.
Random generic approaches are welcome.

No, passing anonymous types about isn't generally a good idea because you lose the type information*. You should create a concrete type and use that instead.
var subset = DataTable.Where(...).Select(row => new SomeType
{
Id = Convert.ToInt32(row["Id"]),
Name = row["Name"].ToString(),
Email = row["Email"].ToString()
});
Alternatively you can use the Tuple type if you are using .NET 4. This is a simple way to create "disposable" types and still get some type-safety.
*Actually there is a workaround, but I regard it is an ugly hack and would advise that you don't do it.

If I need to do this, I use resharper's "Replace Anonymous Type With Named Class" refactoring option. Then you have an appropriate named type to expose over the API, and you haven't had to do any work. This also gives you options to create it immutable (like anonymous types) or mutable, nested vs top-level, etc.
BTW, I don't recommend struct here (from the question).
Another option is to pass the behaviour into the method - i.e. an Action<int,string,string> callback - then do something like:
foreach(item in query) callback(item);
However, I don't like this as it is not obvious that there is a likely error in:
DoSomething(args, (id, email, name) => Email(To: email, Subject: name));
(the error being that it should probably be (id, name, email), if you see what I mean)

You can use a generic method:
public static void Foo<T>(T item)
{
// Do whatever
}
Then if you call
Foo(subset);
the compiler will infer T for you. Whether or not that actually helps you is another matter... it depends on what the method is meant to do. Obviously Foo can't refer to Id, Name, Email etc.
In general, if multiple methods should know about the same members, then you should use a named type. The usual case for passing them to generic methods is where the method really doesn't care about what type is involved, such as in LINQ.
I've made a feature request for C# 5 that we should be able to create types which have all the same features as anonymous types (immutability, equality, hash code generation, ToString dumping) but for simple named types. We'll see if it actually happens...

Anonymous Types don't provide much help outside of the context they where created.
If you need to pass an Anonymous Type to a method, either this method is very generic like (Example)
void PrintAllObjectProperties(object obj);
witch you would use reflection to do the work, or you are doing something wrong.

Here's what I came up with...
Extension method on Object:
public static class ObjectExtensions
{
/// <summary>
/// Cast Object to anonymous type.
/// E.G.: new Object().ToAnonymousType(new { Property = new Type() });
/// </summary>
public static T ToAnonymousType<T>(this Object o, T t)
{
return (T)o;
}
}
Usage:
public void HandleAnonymousTypeAsParameter(Object o)
{
var anonymousType = o.ToAnonymousType(new
{
Id = new Int32(),
Foo = new String(),
Bar = new String()
});
// ... You can do this in even less characters:
var anonymousType = o.ToAnonymousType(new { Id = 0, Foo = "", Bar = "" });
}
HandleAnonymousTypeAsParameter(new
{
Id = 1,
Foo = "foo",
Bar = "bar"
});
Credits goes to John Skeet and Thomas P.