We Keep Coding

Construct a generic type through reflection given the type of another object

I'm passing a type to a method and creating an object based on that type. Assume argType is a Type and passed to the method as a parameter.
var assembly = AppDomain.CurrentDomain.GetAssemblies().Single(a => a.GetName().Name == "MyAssembly");
var newType = assembly.GetTypes().SingleOrDefault(x => x.FullName == argType.FullName + "Suffix");
var newObject = Activator.CreateInstance(newType);
This works fine for most objects, but if I pass a type with a generic sub type (e.g. MyClass<MyType>), it fails [Assume the goal is to set newObject to a MyClassSuffix<MyType>].
How could the code above be improved so that generic types (ending with "Suffix") can also be created? I looked at the FullName property for such types which contain substrings like '1[[. I'd rather not do regex parsing to append "Suffix" before these characters begin. I'm thinking there is a better way.

You can use MakeGenericType method if you have instance of both types i.e the generic class and the generic type parameter :
// assuming you have a generic class named Class<>
// taking one generic type parameter
Type generic = typeof(MyClassSuffix<>);
Type typeParameter = typeof(MyClass);
Type genericInstance = generic.MakeGenericType(typeParameter);
and then:
object o = Activator.CreateInstance(genericInstance);
In your case you have generic as newType and you would need to figure out which type you need to pass as type parameter and it should work.
Read the following MSDN docs for detailed instructions on this topic:
https://learn.microsoft.com/en-us/dotnet/framework/reflection-and-codedom/how-to-examine-and-instantiate-generic-types-with-reflection
UDPATE:
You can get generic type parameters too following way
var newType = assembly.GetTypes().SingleOrDefault(x => x.FullName == argType.FullName + "Suffix");
if(newType.IsGenericType)
{
// Get the generic type parameters or type arguments.
Type[] typeParameters = t.GetGenericArguments();
// Construct the type Dictionary<String, Example>.
Type constructed = newType.MakeGenericType(typeParameters);
}
If you are having a closed type then you can instantiate it same way like a normal class. See the following example:
public class GenericClass<Int>
{
}
Now we can generate an instance of it like:
Type t = typeof(GenericClass<int>);
object o = Activator.CreateInstance(y);
Console.WriteLine(o);
DEMO Fiddle

'type' is a variable but is used like a type [duplicate]

The following doesn't work, of course. Is there a possible way, which is pretty similar like this?
Type newObjectType = typeof(MyClass);
var newObject = givenObject as newObjectType;

newObjectType is an instance of the Type class (containing metadata about the type) not the type itself.
This should work
var newObject = givenObject as MyClass;
OR
var newObject = (MyClass) givenObject;
Casting to an instance of a type really does not make sense since compile time has to know what the variable type should be while instance of a type is a runtime concept.
The only way var can work is that the type of the variable is known at compile-time.
UPDATE
Casting generally is a compile-time concept, i.e. you have to know the type at compile-time.
Type Conversion is a runtime concept.
UPDATE 2
If you need to make a call using a variable of the type and you do not know the type at compile time, you can use reflection: use Invoke method of the MethodInfo on the type instance.
object myString = "Ali";
Type type = myString.GetType();
MethodInfo methodInfo = type.GetMethods().Where(m=>m.Name == "ToUpper").First();
object invoked = methodInfo.Invoke(myString, null);
Console.WriteLine(invoked);
Console.ReadLine();

You can check if the type is present with IsAssignableFrom
if(givenObject.GetType().IsAssignableFrom(newObjectType))
But you can't use var here because type isn't known at compile time.

I recently had the case, that I needed to generate some code like in Tomislav's answer. Unfortunately during generation time the type T was unknown. However, a variable containing an instance of that type was known. A solution dirty hack/ workaround for that problem would be:
public void CastToMyType<T>(T hackToInferNeededType, object givenObject) where T : class
{
var newObject = givenObject as T;
}
Then this can be called by CastToMyType(instanceOfNeededType, givenObject) and let the compiler infer T.

You can use Convert.ChangeType. According to msdn, it
returns an object of a specified type whose value is equivalent to a
specified object.
You could try the code below:
Type newObjectType = typeof(MyClass);
var newObject = Convert.ChangeType(givenObject, newObjectType);

Maybe you can solve this using generics.
public void CastToMyType<T>(object givenObject) where T : class
{
var newObject = givenObject as T;
}

Get the actual type from a Type variable

I am trying to get a type from a Type variable. For example:
Type t = typeof(String);
var result = SomeGenericMethod<t>();
An error happens on the second line, because t is not a type, it's a variable. Any way to make it a type?

To make an instance of a generic based on a Type, you can use reflection to get an instance of the generic with the type you want to use, then use Activator to create that instance:
Type t = typeof (string); //the type within our generic
//the type of the generic, without type arguments
Type listType = typeof (List<>);
//the type of the generic with the type arguments added
Type generictype = listType.MakeGenericType(t);
//creates an instance of the generic with the type arguments.
var x = Activator.CreateInstance(generictype);
Note that x here will be an object. To call functions on it, such as .Sort(), you'd have to make it a dynamic.
Please Note that this code is hard to read, write, maintain, reason about, understand, or love. If you have any alternatives to needing to use this sort of structure, explore those thoroughly.
Edit: You can also cast the object you receive from the Activator, such as (IList)Activator.CreateInstance(genericType). This will give you some functionality without having to resort to dynamics.

No, you cannot know the value of a Type object at compile time, which is what you would need to do in order to use a Type object as an actual type. Whatever you're doing that needs to use that Type will need to do so dynamically, and not require having a type known at compile time.

An ugly workaround using reflection:
Class with generic Method
public class Dummy {
public string WhatEver<T>() {
return "Hello";
}
}
Usage
var d = new Dummy();
Type t = typeof(string);
var result = typeof(Dummy).GetMethod("WhatEver").MakeGenericMethod(t).Invoke(d, null);
On class instantiation see Max's solution

How can I find the type of T in a c# Generic collection of T when all I know is the type of the collection?

I have an array of PropertyInfo representing the properties in a class. Some of these properties are of type ICollection<T>, but T varies across the properties - I have some ICollection<string>, some ICollection<int>, etc.
I can easily identify which of the properties are of type ICollection<> by using the GetGenericTypeDefinition() method on type, but I am finding it impossible to get the type of T - the int or string in my example above.
Is there a way to do this?
IDocument item
PropertyInfo[] documentProperties = item.GetType().GetProperties();
PropertyInfo property = documentProperties.First();
Type typeOfProperty = property.PropertyType;
if (typeOfProperty.IsGenericType)
{
Type typeOfProperty = property.PropertyType.GetGenericTypeDefinition();
if (typeOfProperty == typeof(ICollection<>)
{
// find out the type of T of the ICollection<T>
// and act accordingly
}
}

If you know it'll be ICollection<X> but don't know X, that's fairly easy with GetGenericArguments:
if (typeOfProperty.IsGenericype)
{
Type genericDefinition = typeOfProperty.GetGenericTypeDefinition();
if (genericDefinition == typeof(ICollection<>)
{
// Note that we're calling GetGenericArguments on typeOfProperty,
// not genericDefinition.
Type typeArgument = typeOfProperty.GetGenericArguments()[0];
// typeArgument is now the type you want...
}
}
It gets harder when the type is some type which implements ICollection<T> but may itself be generic. It sounds like you're in a better position :)

I believe this is what you are looking for:
typeOfProperty.GetGenericArguments()[0];
That will return you the T part of a generic List<T> for example.

Jon's solution will yield T. Depending on the context, you might need to access the getter return type instead in order to get int, string, etc. For example...
// The following example will output "T"
typeOfProperty = property.PropertyType.GetGenericTypeDefinition();
Type genericDefinition = typeOfProperty.GetGenericTypeDefinition();
if (genericDefinition == typeof(ICollection<>))
{
Type t1 = typeOfProperty.GetGenericArguments()[0];
Console.WriteLine(t1.ToString());
}
// Instead you might need to do something like the following...
// This example will output the declared type (e.g., "Int32", "String", etc...)
typeOfProperty = property.GetGetMethod().ReturnType;
if (typeOfProperty.IsGenericType)
{
Type t2 = typeOfProperty.GetGenericArguments()[0];
Console.WriteLine(t2.ToString());
}

How to cast to a type in C#

Can anyone explain how to get this to work? I am passing in the type name, and "t" is being correctly populated. I just cannot figure out how to cast objectToCast to type "t". Any help is appreciated.
....
Type t = Type.GetType("castToTypeNameHere");
o = CastTo<t>(objectToCast);
....
private T CastTo<T>(Object obj)
{
return (T)obj;
}
FYI, here's the answer I found:
Type t = Type.GetType(element.Attribute("castToType").Value);
MethodInfo castMethod = this.GetType().GetMethod("CastTo", BindingFlags.Instance | BindingFlags.NonPublic).MakeGenericMethod(t);
object castedObject = castMethod.Invoke(this, new object[] { objectToCast });

When you use generics (without reflection), the type parameters have to be the name of types, not instances of System.Type. So you can't say
Type t = Type.GetType("castToTypeNameHere");
o = CastTo<t>(objectToCast);
because t is not the name of a type. It's as if you had said
o = CastTo<typeof(int)>(objectToCast);
instead of
o = CastTo<int>(objectToCast);
The former is illegal, the latter is legal.
I don't understand what you're trying to achieve. If you don't know the type at compile time, a cast like that is useless. The compiler won't know the type of o, and you won't get any of the compile-time type safety nor IntelliSense features.

You can't use a variable for a generic type parameter (e.g., CastTo<t>)—it has to be the actual type name (e.g., CastTo<string>).

Perhaps Convert.ChangeType would help you here.
Type t = Type.GetType("castToTypeNameHere");
//using dynamic
dynamic obj = Convert.ChangeType(objectToCast, t);
obj.SomeExpectedMethod();
//casting to known interface
var obj = Convert.ChangeType(objectToCast, t) as IKnowWhatImSupposedToBe;
if (obj == null) HandleBadState();

If you think the answer you said you found:
Type t = Type.GetType(element.Attribute("castToType").Value);
MethodInfo castMethod = this.GetType().GetMethod("CastTo", BindingFlags.Instance | BindingFlags.NonPublic).MakeGenericMethod(t);
object castedObject = castMethod.Invoke(this, new object[] { objectToCast });
actually does something, then you don't understand what casting means.
The compile time type is still object, so you've gained nothing. You can directly just cast anything as object directly.
Casting doesn't change the type of an object, it only tells the compiler that you know what type it is, and the compiler will believe you. If you're wrong an error will still happen, only it's at runtime with an InvalidCastException instead of at compile time.
The problem is that casting to a type that isn't know at compile time just doesn't make sense. Even if you could hypothetically, what would that give you?
Type someType = Type.GetType("castToTypeNameHere");
someType o = CastTo<someType>(objectToCast);
What methods does o have? someType could be anything, so there's no way the compiler can know what methods or properties it has, It would be exactly the same as
object o = (object)objectToCast
Because there's nothing you could do with someType that you couldn't with object.