求助一个取Dictionary<string, object>的value转换类型的问题

Question

我定义了一个Dictionary<string, object>变量，
里面的value放的是一些IList的对象，key是这个IList的泛型类型的字符串
现在要循环这个Dictionary根据每个key值把value取出来并转换成相应的类型，请问要怎么弄·
可以用CreateInstance吗？

Answer 1

Dictionary<string, object> dic = new Dictionary<string, object>();
foreach (KeyValuePair<string, object> obj in dic)
{
   IList<string> list = (IList<string>)obj.Value;
}

Answer 2

根据key去value可以用TryGetValue
转换的话 可以强制转换

Answer 3

value放的不是IList<string>，是其他类型的IList，就是一些映射数据库表结构的实体··

Answer 4

强制转换就好,无需根据Key来创建泛型列表.
CreateInstance 返回的依旧是Object,所以还是需要强制转换.

Answer 5

我知道强制转换啊 问题是value的类型是不一定的··所以不知道该用什么类型转···

Answer 6

可以根据key 使用TryGetValue()

Answer 7

List<IList<T>> GetItems<T>(Dictionary<string, object> dict)
{
    return dict.Where(x => x.Key == typeof(T).ToString()).Select(x => x.Value as IList<T>).ToList();
}

Answer 8

调用：取得所有IList<string>:foreach (IList<string> item in GetItems(dict))
{
    item.ToList().ForEach(x => Console.WriteLine(x));
}

Answer 9

这个可以按类型取出Dictionary中的数据,前提是你要知道取哪个类型的数据.

Answer 10

是了··实际上用泛型是可以解决这个问题··但是由于类型有太多 这样写会累死
实际上我的Dictionary里面就是以表名为key 把所有从数据库加载来的数据放进去·
最后更改的时候需要取出来转换成他们本来的类型

Answer 11

 foreach (KeyValuePair<string, object> keyValue in dic)
                {
                    Type type = Type.GetType(keyValue.Key);
                    type objList = (type)keyValue.Value;
                }我想要的就是类似的效果，当然type是一个变量他不能用来指定类型和强制转换，所以才来请教

Answer 12

我还是很好奇,即使可以这样做,你的objList接下来要干嘛呢?如果你是要赋给一个已知类型的变量,完全就可以通过它们的类型比较来赋值,无需强类型化.

Answer 13

不需要强制类型转换。如果你不使用泛型，用什么类型接收呢？还得用 IList<object>。那你转换还有意义么？如果你用具体的类型接收，说明编译期可以得到类型。那为什么不使用泛型呢？

Answer 14

你预备怎么在客户端掉用这个函数（假设你写出来了）IList<MyClass> list = GetItems("MyClass", dict).First(); // 我的写法
IList<object> list = GetItems("MyClass", dict); // 无需转换

Answer 15

里面有些事情要处理··我需要处理每一个objList里的状态···

Answer 16

可以把Dictionary<string, object>改为Dictionary<string, IList<基类>>吗？
这样就可以
            foreach (KeyValuePair<string, IList<基类>> keyValue in dic)
            {
                foreach (基类 value in keyValue.Value) ;//处理状态
            }

Answer 17

直接 Dictionary<string, IList<object>>   foreach (string keyValue in dic.Keys)
 {
       dic[keyValue] //这个就是 value         
}       

Answer 18

现在发现基类不行··首先是转成基类对象为null，然后是基类没有办法满足后来要的操作，我要操作的属性都是继承后加的

Answer 19

定义的时候就应该是IList<基类>，否则通过其它方式转的话就是两个不同的IList对象了。
操作的属性后加的没关系，关键是操作接口是确定的，可以用虚方法。

Answer 20

如果IList<>的定义无法修改的话，有个比较麻烦的包装方法
public abstract class 基类
        {
            public abstract void 状态处理();
        }
        public class 子类1 : 基类
        {
            public override void 状态处理() { }
        }
        public class 子类2 : 基类
        {
            public override void 状态处理() { }
        }
        public class 包装类
        {
            private Action<object> 状态处理委托;
            private object 对象集合;
            public static 包装类 set<子类>(IList<子类> 对象集合) where 子类 : 基类
            {
                return new 包装类
                {
                    对象集合 = 对象集合,
                    状态处理委托 = (IList) =>
                    {
                        foreach (子类 对象 in (IList<子类>)IList)
                        {
                            对象.状态处理();
                        }
                    }
                };
            }
            public IList<子类> get<子类>() where 子类 : 基类
            {
                return 对象集合 as IList<子类>;
            }
            public void 状态处理()
            {
                状态处理委托(对象集合);
            }
        }
        private static void Example()
        {
            List<子类1> value1 = new List<子类1>();
            List<子类2> value2 = new List<子类2>();
            Dictionary<string, 包装类> dic = new Dictionary<string, 包装类>();
            dic.Add(value1.GetType().FullName, 包装类.set(value1));
            dic.Add(value2.GetType().FullName, 包装类.set(value2));
            foreach (KeyValuePair<string, 包装类> keyValue in dic)
            {
                keyValue.Value.状态处理();
            }
        }