Develop Reference

C# alternative to tuple

I have a dbf file (dBase) that I want to read, put each row into a single list (since a row represents data about one shapefile object), and then be able to modify the list (e.g., convert fields which represent the name to a string). This means that the datatype need to be able to hold both Ints, strings, bool and so on, and add items to, it. In python I could do this with lists, but since sets cant be modified, I cant use them.
This sounds like a (exact) duplicate to Alternative to Tuples,
but it isn't. These questions are based on the assumption that you know which objects you want beforehand; I don't.
I'm on .NET 4.5, btw.

Use dynamic - it is a perfect use case for it:
Visual C# 2010 introduces a new type, dynamic. The type is a static type, but an object of type dynamic bypasses static type checking. In most cases, it functions like it has type object. At compile time, an element that is typed as dynamic is assumed to support any operation. Therefore, you do not have to be concerned about whether the object gets its value from a COM API, from a dynamic language such as IronPython, from the HTML Document Object Model (DOM), from reflection, or from somewhere else in the program. However, if the code is not valid, errors are caught at run time.

If you want to be able to easily add properties at runtime and change their types, you can use ExpandoObject with dynamic, for example:
dynamic expando = new ExpandoObject();
expando.SomeProperty = "1234";
Console.WriteLine(expando.SomeProperty);
Console.WriteLine(expando.SomeProperty.GetType().FullName); // string
expando.SomeProperty = int.Parse(expando.SomeProperty);
Console.WriteLine(expando.SomeProperty);
Console.WriteLine(expando.SomeProperty.GetType().FullName); // int

Have you tried using the dynamic type?

Serialize an object without the object's information

I am in a situation I need to serialize only the values of the members of an object to a file.
for example, if the object contains 3 string members I would want the output of the serialization to be only this 3 strings without the serialization metadata the Binaryformatter adds, like the version, culture, and assembly name of the object.
One option is just to write each members of the object directly, but I want to avoid this because I have lots of classes that need to be serialize like this and I don't want to write a function that handles this differently for each class.
Requirements:
I want to be able to write to any type of file, I want the values of the members to be translated to bytes (into a buffer or directly into the file) and to be able to write those bytes at a specific position in the file.
Is there a way or an API of serializing only the value of the members of an object?

Matan,
Here is some code I put together for an entirely different purpose, but it takes an unknown object and serializes it into an XML file (updated to include better coding practices).
void objectToXMLFile(String fn, object o)
{
XmlTextWriter textWriter = new XmlTextWriter(fn, null);
System.Type type = o.GetType();
PropertyInfo[] piList = type.GetProperties();
textWriter.WriteStartDocument();
textWriter.WriteStartElement("attributeList");
foreach (PropertyInfo pi in piList)
{
textWriter.WriteStartElement("attribute");
textWriter.WriteStartElement("name");
textWriter.WriteString(pi.Name);
textWriter.WriteEndElement();
textWriter.WriteStartElement("value");
textWriter.WriteString(pi.GetValue(o).ToString());
textWriter.WriteEndElement();
textWriter.WriteStartElement("dataType");
textWriter.WriteString(pi.PropertyType.Name);
textWriter.WriteEndElement();
textWriter.WriteEndElement();
}
textWriter.WriteEndElement();
textWriter.WriteEndDocument();
textWriter.Close();
}

If you do end up using Reflection to only write the wanted properties, you may want to consider some performance implications.
Using Reflection is slow. Reflecting the type itself has a high price, and then dynamically invoking the PropertyInfo by calling PropertyInfo.GetValue is very slow.
An alternative is to build an Expression tree that calls the properties and writes their values, and then compile this expression into an Action. You can cache these Action instances in a dictionary keyed by the Type of the object you are serializing, and invoke the right one when you want to serialize the object.
That would be much much faster and will also not create so much load on the GC.
Another alternative you may consider is code generation at build time - you can generate a class to serialize your target type quickly and cheaply. In some scenarios this is a good choice.

Convert object to System.Type in linq

I need to cast an object to a System.Type object.
I've read that C# is statically typed so that would not be possible.
Is this true?
If yes, how can I accomplish this?
Assembly myDll = Assembly.LoadFrom(dllData.Path);
Type manyAttribute = myDll.GetExportedTypes().FirstOrDefault(...);
Type multiplicityAttribute = myDll.GetExportedTypes().FirstOrDefault(..);
//Here is the problem
propertiesOnOtherFile = propertiesOnOtherFile.Where(t =>
t.GetCustomAttributes(false).Any(ca =>
!string.IsNullOrEmpty(((multiplicityAttribute)ca).PropertyName)));
This is the line:
((multiplicityAttribute)ca).PropertyName)
Is there any other way to do this?
EDIT:
Due to many questions, this is my scope:
public class PocoClass
{
[ManyAttribute]
public ObjectX MyProp;
}
ManyAttribute declaration
{
public string PropertyName;
}
ManyAttribute is in the dynamicly loaded DLL.
Then, as in my example above, I need to cast the customAttribute (ManyAttribute) to ManyAttribute so I check PropertyName's value.

I still don't get this... but this should work.
IEnumerable<Type> propertiesOnOtherFile = new List<Type>(); //from somewhere?
//Here is the problem
propertiesOnOtherFile = propertiesOnOtherFile.Where(t =>
t.GetCustomAttributes(false).Any<dynamic>(ca =>
!string.IsNullOrEmpty(ca.PropertyName)));

There are only two ways to access properties/methods of something without knowing its type at compile time. You're certainly in this situation:
reflection – gets fairly cumbersome very quickly, even for basic things, but allows you to do pretty much anything you want.
dynamic – makes C# behave similarly to dynamically typed languages, but does not allow you to do things like accessing a property whose name is also dynamic.
Since in your case the property names are also dynamic, I would say that the answer is no, there is no better way to manipulate objects and properties when they aren't known at compile time.
You would do well to design your architecture in such a way as to avoid accessing objects in quite such a dynamic way, but there is too little context to recommend a specific approach.

What you're attempting to do doesn't make sense.
This line: Type multiplicityAttribute = myDll.GetExportedTypes().FirstOrDefault(..); gets a Type that you're attempting to bind to, dynamically.
Then you're trying to cast against it: (multiplicityAttribute)ca)
What are you going to do once you have it cast?
Are you:
Attempting to get names of properties?
Attempting to get a list of object types that have some property?
Attempting to get the value of some static property?
Attempting to get the value of some instance property, but you don't know the name of the class that is defining the instance?
What it seems like you're trying to do is create a generalizable approach to inspecting for something that in reality is pretty specific. When working with Reflection, it's commonly easier to go the other direction: solve the specific case first, and then refactor to more generalizable approaches.

How to create a value type or string type object at runtime using Reflection

Probably simple but could not figure out. I am loading an assembly at runtime and browsing through some classes and generating input controls for its properties. To create an instance of an object at runtime I am using:
object o = PropertyType.GetConstructor(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public, null, Type.EmptyTypes,null).Invoke(null);
and it works fine for class types. When the type is an array, I use
object o = PropertyType.Type.GetConstructor(new Type[] { typeof(int) }).Invoke(new object[] { 0 });
which also works fine. But when it comes to string type or value types GetConstructor.Invoke does not work. I also tried Activator.CreateInstance which also did not work.

What you're running into is that value types don't really have parameterless constructors. C# makes it look like they do, but they don't at the CLR level.
Activator.CreateInstance should work fine for real value types though:
object o = Activator.CreateInstance(typeof(int));
Console.WriteLine(o); // Prints 0
This will always give the default value for any value type.
Now, you're asking about strings - what string would you expect to create? The default value for the string type is null - but would you want the empty string instead? If so, you'll need to special-case that code.

If you want to be able to instantiate arbitrary objects with particular values, one thing you can check is if there is a TypeConverter that supports converting an instance (with the value you want to match) to an InstanceDescriptor. I'm not entirely sure what you're doing (your example suggests you're trying to create 'default' instances of the different objects), but just thought I'd mention this in case it's relevant. I use this in Emit code to emit arbitrary constant values to the stack via IL. Here's the snippet that gets the InstanceDescriptor:
var converter = TypeDescriptor.GetConverter(value);
if (converter.CanConvertTo(typeof (InstanceDescriptor)))
{
var desc = (InstanceDescriptor) converter.ConvertTo(value, typeof (InstanceDescriptor));
}
The descriptor specifies a means of constructing the instance, which could be calling a constructor, calling a static method, accessing a static property or accessing a static field. It also specifies whether the construction completely sets the value of the type to match your original instance; if not, you'll need to do additional reflection and setting of properties.
This is the mechanism that the WinForms Designer uses when generating the code-behind for the controls on the form, so it is supported for the common types that show up as properties of controls accessible from the designer.

The int type doesn't have any constructors.
The code you write is going to depend on the property's type; normally, you'd write special-case code for string, int and other primitive types.
Your code above contains the literal 0; how do you decide what values to pass to the constructors?

Get property value dynamically

I have an object which has a huge number of properties. I'd like to get the value of each of those properties by simply looping through the properties collection of the object.
I've looked into the PropertyInfo.GetValue() method however it's not making much sense in the context I have.
Here's an example of what i'm trying to do (this code doesn't work btw):
foreach(var item in dataObjects)
{
foreach(PropertyInfo prop in item.GetType().GetProperties())
{
String value = prop.GetValue().ToString()
}
}
I realise now that getting the value of a property isn't this easy. What am I missing? I don't really understand what I need to pass to the GetValue() method because I simply want the value of the property I'm calling that method on.
Thanks for any help clarifying this for me. I've spent a couple of hours here just banging my head against the desk.

You need to provide the specific object on which you want to call the property in question:
prop.GetValue(item, null);
The PropertyInfo is just metatdata about the property on the type, not on the specific object instance. The PropertyInfo doesn't know which instance it came from (if any) - just the type/class it came from.
You can almost think of the PropertyInfo as just the name of the property. That's not enough information to do anything with it alone - we then have to say "get the value of the property with this name on... what?" On the object we provide.

PropertyInfo represents the property machinery itself (type, get method, set method, et cetera), not a property bound to a specific instance. If the property is nonstatic, you must provide an instance to read that property from -- that's the first parameter to GetValue. In other words, if pi is a PropertyInfo representing the Test property on some class and someObject is an instance of that class:
object a = someObject.Test;
object b = pi.GetValue(someObject, null);
both lines there get the value of the same property on the same object. If the property is static, you don't need to pass the instance, obviously (pass null instead). The second parameter is the index for indexed properties -- C# does not support indexed properties (it supports indexers, which are not exactly the same), so you will likely never need to pass anything but null for that second parameter unless you're working with some type from an assembly written in a language that does support indexed properties (like VB, I believe).