Question

以下作品，测试通过。但是我不乐意在调用中显式传递程序集名称。还有更好的方法吗？

public static object ToType<T>(this object obj, T type, string assembly, IDictionary<string,string> maps) {
    //create instance of T type object:
    var tmp = Activator.CreateInstance(assembly, type.ToString()); 

    foreach( var map in maps) {
        try 
        {   
            PropertyInfo source = obj.GetType()
                .GetProperty(map.Value);

            tmp.Unwrap().GetType().GetProperty(map.Key)
                .SetValue(tmp.Unwrap(), source.GetValue(obj, null), null);
        }
        catch 
        {
            throw new ArgumentException("Error converting to Type: "+type);
        }
    }
    return tmp.Unwrap();
}

[Test]
public void TestToTypeExtension()
{
    Source item = new Source();
    item.OtherObj_One     = "1234567890";
    item.OtherObj_Code      = "IBM.N";
    item.OtherObj_CodeType  = "S";
    item.OtherObj_CodeGroup = "EQUITY";

    Target row = (Target)item.ToType(typeof(Target), ((typeof(Target)).Assembly).FullName, Target.map);

    Assert.AreEqual(item.OtherObj_One, row.One);
    Assert.AreEqual(item.OtherObj_Code, row.Code);
    Assert.AreEqual(item.OtherObj_CodeType, row.CodeType);
}

public class Target
{
    public static Dictionary<String, String> map = new Dictionary<string, string>{
                                                    {"One"          ,"OtherObj_One"},
                                                    {"Code"         ,"OtherObj_Code"},
                                                    {"CodeType"     ,"OtherObj_CodeType"},

    };

    public String One { get; set; }
    public String Code { get; set; }
    public String CodeType { get; set; }

}

public class Source
{
    public String OtherObj_One { get; set; }
    public String OtherObj_Code { get; set; }
    public String OtherObj_CodeType { get; set; }
    public String OtherObj_CodeGroup { get; set; }

}

更新

在扩展方法中执行的((typeof(T)).Assembly).FullName的值为：mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089

如果我将对象创建语句更改为T tmp = Activator.CreateInstance<T>();，则会收到以下错误：

Test Name:  TestToTypeExtension
Test FullName:  Solution.Test.UtilsTests.TestToTypeExtension
Test Source:    [ ... ]\UnitTestProject1\UtilsTests.cs : line 39
Test Outcome:   Failed
Test Duration:  0:00:00.071

Result Message: System.MissingMethodException : Cannot create an abstract class.
Result StackTrace:  
at System.RuntimeTypeHandle.CreateInstance(RuntimeType type, Boolean publicOnly, Boolean noCheck, Boolean& canBeCached, RuntimeMethodHandleInternal& ctor, Boolean& bNeedSecurityCheck)
at System.RuntimeType.CreateInstanceSlow(Boolean publicOnly, Boolean skipCheckThis, Boolean fillCache, StackCrawlMark& stackMark)
at System.RuntimeType.CreateInstanceDefaultCtor(Boolean publicOnly, Boolean skipCheckThis, Boolean fillCache, StackCrawlMark& stackMark)
at System.Activator.CreateInstance[T]()
at Util.MappingExtensions.ToType[T](Object obj, T type, String assembly, IDictionary`2 maps) in [ ... ]\Utils\MappingExtensions.cs:line 22
at Solution.Test.UtilsTests.TestToTypeExtension() in [ ... ]\UnitTestProject1\UtilsTests.cs:line 46

UPDATE2

获胜代码（包括相关的List扩展名）是，谢谢，如下。顺便说一句，扩展适用于匿名类型，例如由linq select new表达式返回的那些（即select new {prop1 = x, prop2 = y}） - 这是我的主要动机。

    public static object ToType<T>(this object obj, IDictionary<string, string> maps) 
           where T : new()
    {
        T tmp = new T();
        Type objType = obj.GetType();
        Type tType = typeof(T);

        foreach( var map in maps) {
            try 
            {   
                 PropertyInfo source = objType.GetProperty(map.Value);

                 tType.GetProperty(map.Key)
                         .SetValue(tmp, source.GetValue(obj, null), null);
             }
             catch 
             {
                 throw new ArgumentException("Error converting to Type: "+ tType);
             }
        }
        return tmp;
    }

    public static List<T> ToTypeList<T,U>(this List<U> source
                  , IDictionary<string, string> maps) 
        where T : new ()
    { 
        List<T> result = new List<T>();

        foreach (var item in source)
        {
            result.Add((T)item.ToType<T>(maps));
        }
        return result;
    }

Answer 1

是的，您已经拥有了所需的代码。只需将其移动到通用函数中即可。

var assembly = ((typeof(T)).Assembly).FullName;

Answer 2

也许更好的东西 - 它大大简化了你的电话：

public static T ToType<T>(this object obj, IDictionary<string, string> maps)
{
    //create instance of T type object:
    var tmp = Activator.CreateInstance(typeof(T).Assembly.FullName, typeof(T).ToString());

    foreach (var map in maps)
    {
        try
        {
            PropertyInfo source = obj.GetType()
                .GetProperty(map.Value);

            tmp.Unwrap().GetType().GetProperty(map.Key)
                .SetValue(tmp.Unwrap(), source.GetValue(obj, null), null);
        }
        catch
        {
            throw new ArgumentException("Error converting to Type: " + typeof(T));
        }
    }
    return (T)tmp.Unwrap();
}

用法：

 Target row = item.ToType<Target>(Target.map);

Answer 3

我会使用Activator.CreateInstance<T>()泛型重载并跳过汇编位。这也会强烈地输入它：

public static object ToType<T>(this object obj, IDictionary<string,string> maps) {
    //create instance of T type object:
    T tmp = Activator.CreateInstance<T>(); 

    foreach( var map in maps) {
        try 
        {   
            PropertyInfo source = obj.GetType()
                .GetProperty(map.Value);

            tmp.Unwrap().GetType().GetProperty(map.Key)
                .SetValue(tmp.Unwrap(), source.GetValue(obj, null), null);
        }
        catch 
        {
            throw new ArgumentException("Error converting to Type: "+ typeof(T));
        }
    }

    return tmp.Unwrap();
}

此外，由于您已经要求类型具有无参数构造函数（通过使用Activator.CreateInstance而不使用参数参数），请考虑使用new constraint来强制编译时安全性：< / p>

public static object ToType<T>(this object obj, IDictionary<string,string> maps) where T : new()
{
    //create instance of T type object:
    T tmp = new T();

    foreach( var map in maps) {
        try 
        {   
            PropertyInfo source = obj.GetType()
                .GetProperty(map.Value);

            tmp.Unwrap().GetType().GetProperty(map.Key)
                .SetValue(tmp.Unwrap(), source.GetValue(obj, null), null);
        }
        catch 
        {
            throw new ArgumentException("Error converting to Type: "+ typeof(T));
        }
    }

    return tmp.Unwrap();
}

您的用法可能看起来像这样，无需投射：

Target row = item.ToType<Target>(Target.map)

我也不确定Unwrap()来电和调用.GetType()会发生什么，但我怀疑它们在这里是多余的，所以也许你的方法可以简化为：< / p>

public static object ToType<T>(this object obj, IDictionary<string,string> maps) where T : new()
{
    //create instance of T type object:
    T tmp = new T();

    Type objType = obj.GetType();
    Type tType = typeof(T);

    foreach( var map in maps) {
        try 
        {   
            PropertyInfo source = objType.GetProperty(map.Value);

            tType.GetProperty(map.Key)
                .SetValue(tmp, source.GetValue(obj, null), null);
        }
        catch 
        {
            throw new ArgumentException("Error converting to Type: "+ tType);
        }
    }

    return tmp;
}

通用ToType（）扩展 - 有更好的方法吗？

3 个答案: