0

我知道以前有人问过这个问题，但是我尝试过的解决方案从未考虑过可为空的类型。

我需要一些能够处理转换的东西

List<string> 到 List<Int32?>，List<string> 到 List<int>，List<string> 到 List<double>

等等

我正在尝试创建如下内容

private void RoutineCompleted(string category, List  Type fieldType = null)
{


//ToNewType is the extension method that I need.
var var convertedList = values.ToNewType(fieldType);

}

我查看了以下代码，但它没有完成这项工作：

 public static IEnumerable Cast(this IEnumerable self, Type innerType)
    {
        var methodInfo = typeof(Enumerable).GetMethod("Cast");
        var genericMethod = methodInfo.MakeGenericMethod(innerType);
        return genericMethod.Invoke(null, new object[] { self }) as IEnumerable;
    }

谁能帮我解决这个问题？

谢谢！

4

5 回答 5

1

Convert.To...如果您可以使用方法进行转换，则不需要扩展

List<string> strList = ...
List<int> intList = strList.Select(s => Convert.ToInt32(s)).ToList();

或者你可以使用Convert.ChangeType

public static IEnumerable<TOut> ConvertTo<TIn, TOut>(this IEnumerable<TIn> list)
{
    return list.Select(o => (TOut)Convert.ChangeType(o, typeof (TOut)));
}

List<string> strList = new List<string>();
IEnumerable<int> intList = strList.ConvertTo<string, int>();
于 2013-04-11T13:35:29.370 回答
1

您正在谈论的转换本身不是强制转换，而是类型转换。

您可以使用 Linq 来完成它们，例如：

var ints = new List(){1,2,3,4,51};
var strings = array.Select(x => x.ToString());

或者

var strings = new List() {"1.56","2.71","3.14"};
var doubles = strings.Select( x => Convert.ToDouble(x));

这些为您提供 IEnumerables，但您可以使用.ToList().

于 2013-04-11T13:41:31.643 回答
0

你可以试试这个：

public static IEnumerable<TTo> ChangeType<TTo, TFrom>(this IEnumerable<TFrom> self)
{
    return self.Select(e => (TTo)Convert.ChangeType(e, typeof(TTo)));
}

编辑：

如果你不想使用泛型，你必须通过 type:Type像这样：

var list = new List<string> {"1", "3", "4", null};
var result = list.ChangeType(typeof (int?));

你可以尝试使用这个：

public static IEnumerable ChangeType(this IEnumerable self, Type type)
{
   var converter = TypeDescriptor.GetConverter(type);
   foreach (var obj in self)
   {
       yield return converter.ConvertFrom(obj);
   }
}
于 2013-04-11T13:40:53.817 回答
0

这是一个简单的 LINQ Select：

IEnumerable<string> values = new[] { "1", "2", "3" };
var converted = values.Select(PerformConversion);

private int? PerformConversion(string input)
{
   ...
}

每次转换都需要不同的方法，或者包含所有转换的参数化方法。例如：

private T? PerformConversion<T>(string input) where T : struct, IConvertible
{
    return (T?) Convert.ChangeType(input, typeof(T));
}
于 2013-04-11T13:43:28.780 回答
0

Convert 类不能处理 Nullable 类型，所以我必须对它们进行特殊处理。

 static void Main(string[] args)
    {
        var strings = new[] { "1","2","3"};
        var ints = strings.ConvertItems<string, int>().ToList();
        var doubles = strings.ConvertItems<string, double>().ToList();
        var nullableints = strings.ConvertItems<string, int?>().ToList();
    }

    public static IEnumerable<TargetType> ConvertItems<SourceType, TargetType>(this IEnumerable<SourceType> sourceCollection)
    {
        var targetType = typeof(TargetType);
        if (targetType.IsGenericType && targetType.GetGenericTypeDefinition() == typeof(Nullable<>))
        {
            targetType = targetType.GetGenericArguments().First();
        }
        return sourceCollection.ConvertItems((source) => (TargetType)Convert.ChangeType(source, targetType));
    }

    public static IEnumerable<TargetType> ConvertItems<SourceType, TargetType>(this IEnumerable<SourceType> sourceCollection, Converter<SourceType, TargetType> convertor)
    {
        foreach (var item in sourceCollection)
        {
            yield return convertor(item);
        }
    }

编辑：弱类型版本，当您只知道运行时的类型时

static void Main(string[] args)
    {
        var strings = new[] { "1","2","3"};
        var ints = strings.ConvertItems(typeof(int));
        var doubles = strings.ConvertItems(typeof(double));
        var nullableints = strings.ConvertItems(typeof(int?));
        foreach (int? item in nullableints)
        {
            Console.WriteLine(item);
        }
    }

    public static IEnumerable ConvertItems(this IEnumerable sourceCollection,Type targetType)
    {
        if (targetType.IsGenericType && targetType.GetGenericTypeDefinition() == typeof(Nullable<>))
        {
            targetType = targetType.GetGenericArguments().First();
        }
        foreach (var item in sourceCollection)
        {
            yield return Convert.ChangeType(item, targetType);
        }
    }
于 2013-04-11T14:00:49.710 回答