调用 Activator.CreateInstance() 实例的方法的类型安全方法？

Question

In the following code, hs.Add(...) cannot compile. Declare hs as dynamic should work but I'm trying not to use it. Is there a type-safe way?

void F(string colName, DbDataReader reader1, DbDataReader reader2)
{
    // .... loop reader1.Read(); reader2.Read()
    var x = reader1[colName];
    var type = x.GetType();
    var hs = Activator.CreateInstance(typeof(HashSet<>).MakeGenericType(type)); 
      // change var to dynamic will work. Trying not to use it.
    hs.Add(x); // Error
    // ...
    hs.Contains(reader2[colName]); // Error

I tried the following since the type of compile-time type of x is unknown.

var hs = (HashSet<object>)Activator.CreateInstance(typeof(HashSet<>).MakeGenericType(type)); 

but it got error of

System.InvalidCastException: Unable to cast object of type
  'System.Collections.Generic.HashSet`1[System.Int32]' to type
  'System.Collections.Generic.HashSet`1[System.Object]'.

Answer 1

Like Peter pointed out, Activator is a method of working with reflection to dynamically create objects without knowing the type at build time. Type "safety" in this method is though checking types or handle type conversion errors such as with Convert.ChangeType .

Note that DbDataReader has some helper functions to work with types such as GetFieldType and GetString which can be called instead using the column index. For example:

int myColumn = 0;
var type = reader1.GetFieldType(myColumn);
if (type == typeof(string))
   string myValue = reader1.GetString(myColumn);

It more or less boils down to some using branching statements instead of reflection to manage your types. Also, you should note that many ORMs like EntityFramework or Dapper, handle a lot of this type conversion for you.

Answer 2

It seems you're wanting to perform some kind of Set Operation (Intersection? Exclusion?) over scalar values. You can solve this problem using generics (and DbDataReader.GetFieldValue<T> ) without needing to use reflection or Activator , like so:

If you intend to call this F function from call-sites where the type of the colName column is known statically (ie at compile time), then convert F to a generic method:

void F<T>( String colName, DbDataReader reader1, DbDataReader reader2 )
{
    Itn32 rdr1Idx = reader1.GetOrdinal( colName );
    Itn32 rdr2Idx = reader2.GetOrdinal( colName );

    HashSet<T> hashSet = new HashSet<T>();

    while( reader1.Read() && reader2.Read() )
    {
        T value1 = reader1.GetFieldValue<T>( rdr1Idx );
        T value2 = reader2.GetFieldValue<T>( rdr2Idx );

        hashSet.Add( value1 );
        hashSet.Add( value2 );
        // etc - whatever logic you want here.
    }
}

Used like so:

F<Int32>( "someIntegerColumn", rdr1, rdr2 );
F<float>( "someNumericColumn", rdr1, rdr2 );
// etc

If the Type being used can only be known at runtime (eg because of user-supplied SQL queries) then we'll have to use Activator , but can still use a HashSet<> indirectly by wrapping it in an adapter:

using System.Collections;

void F( String colName, DbDataReader reader1, DbDataReader reader2 )
{
    Itn32 rdr1Idx = reader1.GetOrdinal( colName );
    Itn32 rdr2Idx = reader2.GetOrdinal( colName );

    Type columnType1 = reader1.GetFieldType( rdr1Idx );
    Type columnType2 = reader2.GetFieldType( rdr2Idx );
    if( columnType1 != columnType2 ) throw new InvalidOperationException( "Columns have different types." );

    var hashSet = (IList)Activator.CreateInstance( typeof(List<>).MakeGenericType( columnType1 ) );

    while( reader1.Read() && reader2.Read() )
    {
        Object value1 = reader1.GetValue( rdr1Idx );
        Object value2 = reader2.GetValue( rdr2Idx );

        hashSet.Add( value1 ); // HashSetAdapter will cast `Object value1` to its internal `T` type.
        hashSet.Add( value2 );
        // etc - whatever logic you want here.
    }
}

class HashSetAdapter<T> : IList<T> // TODO: Implement all of System.Collections.ICollection
{
    private readonly HashSet<T> hs;

    public HashSetAdapter()
    {
        this.hs = new HashSet<T>();
    }

    public void Add( Object value )
    {
        this.hs.Add( (T)value );
    }

    // TODO: Expose any other HashSet operations.
}

Answer 3

Here is the version using reflection.

var x = 1;

var type = x.GetType();
var hs = Activator.CreateInstance(typeof(HashSet<>).MakeGenericType(type));
// hs.Add(x); // Error
var method = hs.GetType().GetMethod("Add");

method.Invoke(hs, new object[] { x });
method.Invoke(hs, new object[] { x + 1 });

It's slower than dynamic if .Invoke() needs to be called millions of times. dynamic seems need more time to setup.