We Keep Coding

value.GetType().IsSubClassOf(ClassBase) give me the error of "'ClassBase' is a type, which is not valid in the given context"

So am trying to check that a property is derived from a base class before storing it in the backing field. However I get the following syntax error 'ClassBase' is a type, which is not valid in the given context for line value.IsSubclassOf(ClassBase) which makes no sense since ClassBase is a Type and IsSubclassOf is expecting a type.
MCV example below
using System;
namespace QuestionIsSubClassOf
{
class Program
{
static void Main(string[] args)
{
var DataStorageClass = new DataStorageClass();
var DerivedClassA = new ClassDedrivedA();
DataStorageClass.TypeOfClassBase = DerivedClassA.GetType();
}
}
public class DataStorageClass
{
private Type _typeOfClassBase;
public Type TypeOfClassBase
{
get { return _typeOfClassBase; }
set
{
if (value.IsSubclassOf(ClassBase))
{
_typeOfClassBase = value.GetType();
}
else
{
throw new ArgumentOutOfRangeException($"{nameof(TypeOfClassBase)} must be a subclass of {nameof(ClassBase)}");
}
}
}
}
public class ClassBase
{
}
public class ClassDedrivedA : ClassBase
{
}
public class ClassDedrivedB : ClassBase
{
}
}

You need to use the typeof operator in C#.
if (value.IsSubclassOf(typeof(ClassBase)))
{
_typeOfClassBase = value.GetType();
}
else
{
throw new ArgumentOutOfRangeException($"{nameof(TypeOfClassBase)} must be a subclass of {nameof(ClassBase)}");
}
The typeof operator returns a Type object which corresponds to the type it was passed as an argument. When you're working on an instance you may not necessarily know what that type is so typeof cannot be used, which is why the GetType() function exists on the object class.
EDIT:
I'd also like to check if you mean to use IsSubclassOf or whether you actually want to use IsInstanceOfType / IsAssignableFrom.
IsSubclassOf does not return true if you're comparing against the same type. Ie
typeof(Type1).IsSubclassOf(typeof(Type1)) //returns false
If you're always comparing instances against a base type then you can use IsInstanceOfType, otherwise you can use IsSubclassOf with an additional check for ==. Alternatively their's IsAssignableFrom but their may be caveats with that. I'd always advice reading the documentation - MSDN in this case.
EDIT 2021-03-14:
I know this is an old question, but with newer versions of C# you can use pattern matching syntax which is much nicer.
// `is` will match for base and derived types
if(value is ClassBase)
_typeOfClassBase = value.GetType();
else
throw new ArgumentOutOfRangeException(...);

Generic Type instance with anonymous type as generic argument, how to convert back to original type properly?

I meet this problem when I need to verify some code path in my UT.
I need to convert back to its original type to verify the data field is correctly set.
I abstract the class define and my UT is now in the main function for this example
public interface ITestInterface { };
public class TestClass<T> : ITestInterface
{
public T member { get; set; }
}
public static class Util
{
public static ITestInterface Create<C>(C t)
{
return new TestClass<C> { member = t };
}
public static ITestInterface CreateInstance()
{
return Create(new
{
p1 = 100,
p2 = "string"
});
}
}
class Program
{
static void Main(string[] args)
{
var a = Util.CreateInstance();
var b = a as TestClass<Object>;
// this will be "null" in this example
// So, how can I convert back to its real type?
// And get the "member" data
}
}
I think this example can explain exactly my question and what I want
Please be more patient about:
why you use the anonymous type
why you use interface
why use template class derived from non-generic interface
I would like to say the code is already there, I cannot change it (at least currently)
What I want to do is:
check if that interface is an instance of some class derived from ITestInterface
if it is, i need to convert back to that type, can verify its member data
So please share some solution/idea based on this scenario.
BTW,
Of course I know I am using "Object" in my last statement to convert back to the type is not good(or obviously wrong), but in fact I do not know which other things I can put here. "object" is just an intuitive try. Please share any property way to handle this case ( maybe more than just something which is just used to replace "object" ).

I'm not saying this isn't an XY problem but to answer the question you asked.
If you are in the same scope as your anonymous type, you can use type inference with generics to cast it back to the anonymous type.
In my example below, I create the anonymously typed item before calling Util.Create so that I have an instance of that type in a variable that I can use later. Then I call the generic method GetAsTestClass<T>, which uses type inference, based on the 2nd parameter, to set T to the anonymous type. Then it returns item as TestClass<T>, where T is your anonymous type.
public void TestMethod1()
{
var anonItem = new
{
p1 = 100,
p2 = "string"
};
var a = Util.Create(anonItem);
var b = GetAsTestClass(a, anonItem);
// this will be "null" in this example
// So, how can I convert back to its real type?
// And get the "member" data
var c = b.member;
Assert.AreEqual(100, c.p1);
}
public TestClass<T> GetAsTestClass<T>(ITestInterface item, T silentType)
{
return item as TestClass<T>;
}
Edit:
Your specific requirements appear to rule out the type-safe options. Below are code samples using the non-type safe methods of reflection and dynamics. Note that for the dynamic version to work, you need a reference to Microsoft.CSharp in your project.
var a = Util.Create(new
{
p1 = 100,
p2 = "string"
});
var memberAnon = a
.GetType()
.GetProperty("member")
.GetValue(a);
var p1 = memberAnon
.GetType()
.GetProperty("p1")
.GetValue(memberAnon);
Assert.AreEqual(100, p1);
or the dynamic way
dynamic dynamicVar = a;
Assert.AreEqual(100, dynamicVar.member.p1);

How to promise the compiler that the generic type will have a certain property?

I'd like to use a certain operation for multiple variable types (both native and objects) so I'm using the generic return type as follows.
private Generic Field<Generic>(String field)
{
if (BagOfJunk.Properties.Contains(field))
return (Generic)BagOfJunk[field];
return default(Generic);
}
This works well (and BagOfJunk is just a property of this from which I'm pulling out Object typed values). Now, during run-time, when a field isn't contained in the bag, I get the default value to be null. Hence, in the code, I need to perform a check as follows.
NumericType protoNumber = Field<NumericType>("beep");
int number = protoNumber != null ? protoNumber.Value : -1;
DateType protoDate = Field<DateType>("boop");
DateTime date = protoDate != null ? protoDate.Value : null;
I'd like to make the code more compact, so I tried to design a method that does the above four lines in one swoop, for a generic type. The result is below but, of course, it doesn't compile, because the type GenericIn isn't specific enough to have a property Value.
private GenericOut Field<GenericIn, GenericOut>(String field)
{
GenericIn input = Field<GenericIn>(field);
if (input != null)
return (GenericOut)input.Value;
return default(GenericOut);
}
How can I ensure the computer that my GenericIn isn't general - by promising that whatever stuff I'll shove into it, it'll always have the property Value in it?
Edit
It should be emphasized that the type of Value needs to be generic ( equivalent to GenericOut). I noticed that I didn't stress that strongly enough. So the interface that can be used need to declare a property of general type like the following.
interface ObjectWithValue { public Generic Value { get; } }

You can use an interface and apply a where constraint on the type to implement that interface, like below:
interface IHasPropertyValue<TValue> {
TValue Value { get; }
}
class MyType {
public TValue Method<T, TValue>(T obj) where T : IHasPropertyValue<TValue> {
return obj.Value;
}
}
EDIT: Modified the code above to make it more specific to the comment asked below.

put that property in an interface (or a class) and use the generic constraint "where":
public interface IMyInterface
{
public object Value { get; set; }
}
public class C<T> where T:IMyInterface

To build upon the answers so far, you need to create an interface that will be implemented by your GenericIn that will both guarantee that it has a property Value and that the property is of type GenericOut.
interface IHasValue<TOut>
{
TOut Value { get; }
}
private TOut Field<TIn, TOut>(string field) where TIn : IHasValue<TOut>
{
var input = Field<TIn>(field);
return input == null ? default(TOut) : input.Value;
}

Accessing inner type of ICollection<SomeInnerClass> through reflection in c#

I'm attempting to set a property on an object using reflection.
The property is an ICollection - if the Collection has not been instantiated, I want to get that done. My problems is that I'm having issues getting the inner type of the ICollection
This is my class
public class Report(){
public virtual ICollection<Officer> OfficerCollection { get; set; }
}
I'm trying to access the 'Officer' class defined below through reflection
public class Officer(){
public string Name{ get; set; }
}
Code snippet
Report report = new Report()
PropertyInfo propertyInfo = report.GetType().GetProperty("OfficerCollection");
object entity = propertyInfo.GetValue(report, null);
if (entity == null)
{
//How do I go about creating a new List<Officer> here?
}

Give this a whirl:
Report report = new Report();
PropertyInfo propertyInfo = report.GetType().GetProperty("Officer");
object entity = propertyInfo.GetValue(report, null);
if (entity == null)
{
Type type = propertyInfo.PropertyType.GetGenericArguments()[0];
Type listType = typeof(List<>).MakeGenericType(type);
var instance = Activator.CreateInstance(listType);
propertyInfo.SetValue(...);
}

First of all you have to get the of Officer property:
var propertyType = propertyInfo.PropertyType;
Then you to extract generic type parameter:
var genericType = propertyType.GetGenericArguments()[0];
After that invoke create a generic list:
var listType = typeof(List<>).MakeGenericType(genericType);
Finally create a new instance of generic list:
var listInstance = Activator.CreateInstance(listType);
and... Have fun ;)
EDIT:
It's nice to play sometimes with reflection, but I recommend you to do it this way:
public class Report()
{
private ICollection<Officer> officers;
public virtual ICollection<Officer> Officer
{
get
{
if(officers == null)
officers = new List<Officer>();
return officers;
}
set { officers = value; }
}
}

Ignoring the issue that this whole design sounds terrible, I'll try to answer your question. You can find the type of the property with Type type = ...GetProperty(...).PropertyType. If the type was a concrete type - instead of an interface as it currently is - you could then use System.Activator.CreateInstance(type, null) - where null means no constructor arguments - to create an instance of this concrete type. Given that your property type is actually an interface, you don't know whether you should be creating a list, array, collection or any other type that would satisfy this type. You would then need to use SetValue to assign the instance to the property, but of course we're not able to get this far.
You should take this information to reevaluate your design to not depend on reflection, and instead use generic parameterization (look at the new() constraint) and lazy initialization of properties (if you think that makes sense - we're not mind readers.)

Dynamic type passing and instantiation -- how?

EDIT: changed Activator, still doesn't work.
So I'm pretty (very) new to C# and I'm pretty sure this is a dupe, but I've looked through the previous questions and I still can't work out all the points.
I am trying to reduce code smell by replacing some repeated code with a map over a generic list. Specifically, I have code that looks like
var fooNode = node as IFoo;
var barNode = node as IBar;
var bazNode = node as IBaz;
...
if(fooNode != null)
return new FooThing();
if(barNode != null)
return new BarThing();
if(bazNode != null)
return new BazThing();
...
and I want to generalise it.
Here's my attempt:
var types = new Dictionary<Type, Type>
{
{typeof(IFoo), typeof(FooThing)},
{typeof(IBar), typeof(BarThing)},
...
}
foreach(var entry in types)
{
var castNode = node as entry.Key;
return Activator.CreateInstance(entry.Value);
}
Naturally, it doesn't work: The type or namespace name 'entry' could not be found (are you missing a using directive or an assembly reference?). Can you help? Is this sort of thing even possible in C#?

How about this?
foreach(var entry in types)
{
if (node != null && entry.Key.IsAssignableFrom(node.GetType()))
{
return Activator.CreateInstance(entry.Value);
}
}
The problem is that you are confusing generic type parameters with runtime types and in particular the Type class.
If you know what a type will be at compile time then you can use the generic Activator.CreateInstance<T>() method to create an instance of the underlying object - you can use things like type parameters so that this line of code doesn't need to know what the type is, for example:
T CreateObject<T>()
{
return Activator.CreateInstance<T>();
}
However this just passes the buck. In order to call this method the value of the type parameter T must be supplied somewhere - either way the compiler must be able to resolve T to a type (rather than a variable or method).
Conversely the Type class encodes type information at runtime such as its name or the assembly that a type is declared in. Activator.CreateInstance also comes with an overload that allows you to supply an instance of Type:
object CreateObject(Type type)
{
return Activator.CreateInstance(type);
}
In your case it looks like you don't know what the types will be at compile time, so you will be mostly working with the Type class - you can use typeof(MyClass) to get an instance of the the corresponding Type for a class known at runtime, and myObject.GetType() to get type information for an object at runtime.

var types = new Dictionary<Type, Type>
{
{typeof(IFoo), typeof(FooThing)},
{typeof(IBar), typeof(BarThing)},
...
}
foreach(var entry in types)
{
if(entry.Key.IsAssignableFrom(node.GetType()))
return Activator.CreateInstance(entry.Value);
}
return null;

Without understanding clearly your purpose for wanting to return different types from the same operation it will be hard to help. Maybe a little background information into the problem you are trying to solve??
I will assume that since you are attempting to return them interchangeably that fooThing, BartThing and BazThing have the same interface. So I am assuming the following:
public class FooThing : IMyOperations
{
}
public class BarThing : IMyOperations
{
}
public class BazThing : IMyOperations
{
}
You can define the relationship between the classes in another interface
public interface IMyChoice
{
public bool IsSelected { get; }
public IMyOperations GetWorker();
}
public class ChoiceFoo : IMyChoice
{
}
public class ChoiceBar : IMyChoice
{
}
public class ChoiceBaz : IMyChoice
{
}
Now you can say
foreach( var entry in choices)
{
if(entry.IsSelected)
{
return entry.GetWorker();
//Can't remember if i need to break after return..doubt it
}
}