Rust中Rc<dyn Any>向下转型为Rc<GenericType<T>>失败求助

我尝试实现一个可检索不同（但严格类型化）实例的异构存储，使用了Any trait。测试触发panic，提示“downcast failed”。想确认是否因为使用Rc而非Box导致问题？实际项目中我使用Arc<RwLock<GenericType<T>>>，需要支持Send + Sync以适配异步代码，求解决方案。

对应的测试代码如下：

use std::any::type_name;
use std::any::Any;
use std::any::TypeId;
use std::rc::Rc;
use std::collections::HashMap;

struct GenericType<T>(T);

struct HeterogeneousStorage {
    map: HashMap<TypeId, Rc<dyn Any>>,
}

impl HeterogeneousStorage {
    pub fn add<T: 'static>(&mut self, item: Rc<GenericType<T>>) -> &mut Self {
        let ty = TypeId::of::<T>();
        self.map.insert(ty, item);
        self
    }
    
    pub fn retrieve<T: 'static>(&self) -> Rc<GenericType<T>> {
        self.map
            .get(&TypeId::of::<T>())
            .map(|item| {
                let item = item.clone();
                item.downcast_ref::<Rc<GenericType<T>>>()
                .expect("downcast failed")
                .clone()
            })
            .unwrap_or_else(|| panic!("tried to retrieve {} but it was not added", type_name::<T>()))
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn downcasts_correctly() {
        struct Test;
        struct Test2;
        let mut store = HeterogeneousStorage {
            map: HashMap::new()
        };
        let t1 = Rc::new(GenericType(Test));
        let t2 = Rc::new(GenericType(Test2));
        store.add(t1.clone());
        store.add(t2.clone());
        
        assert!(Rc::ptr_eq(&t1, &store.retrieve::<Test>()));
        assert!(Rc::ptr_eq(&t2, &store.retrieve::<Test2>()));
        
    }
}

核心问题 #

不是Rc的问题，而是类型转换逻辑错误：

• 在add方法中，你把Rc<GenericType<T>>转成了Rc<dyn Any>，此时dyn Any的实际底层类型是GenericType<T>，而非Rc<GenericType<T>>。
• 但在retrieve方法中，你尝试用downcast_ref::<Rc<GenericType<T>>>()去转型，这自然会失败——因为存储的内容根本不是Rc<GenericType<T>>，而是被Rc包裹的GenericType<T>。

修复后的Rc版本代码 #

直接使用Rc::downcast方法，将Rc<dyn Any>直接转换为Rc<GenericType<T>>，这是最直接且高效的方式：

use std::any::type_name;
use std::any::Any;
use std::any::TypeId;
use std::rc::Rc;
use std::collections::HashMap;

struct GenericType<T>(T);

struct HeterogeneousStorage {
    map: HashMap<TypeId, Rc<dyn Any>>,
}

impl HeterogeneousStorage {
    pub fn add<T: 'static>(&mut self, item: Rc<GenericType<T>>) -> &mut Self {
        let ty = TypeId::of::<T>();
        self.map.insert(ty, item);
        self
    }
    
    pub fn retrieve<T: 'static>(&self) -> Rc<GenericType<T>> {
        self.map
            .get(&TypeId::of::<T>())
            .map(|item| {
                // 直接对Rc<dyn Any>调用downcast，获取目标类型的Rc包裹
                item.downcast::<GenericType<T>>()
                    .expect("downcast failed")
            })
            .unwrap_or_else(|| panic!("tried to retrieve {} but it was not added", type_name::<T>()))
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn downcasts_correctly() {
        struct Test;
        struct Test2;
        let mut store = HeterogeneousStorage {
            map: HashMap::new()
        };
        let t1 = Rc::new(GenericType(Test));
        let t2 = Rc::new(GenericType(Test2));
        store.add(t1.clone());
        store.add(t2.clone());
        
        assert!(Rc::ptr_eq(&t1, &store.retrieve::<Test>()));
        assert!(Rc::ptr_eq(&t2, &store.retrieve::<Test2>()));
        
    }
}

适配Arc<RwLock<GenericType<T>>>的异步友好版本 #

针对你实际项目中需要Send + Sync的场景，只需要做以下调整：

1. 给dyn Any加上Send + Sync约束，确保存储的类型能跨线程安全传递。
2. 使用Arc::downcast方法完成类型转换，逻辑和Rc版本完全一致。

use std::any::{type_name, Any, TypeId};
use std::collections::HashMap;
use std::sync::{Arc, RwLock};

struct GenericType<T>(T);

struct HeterogeneousStorage {
    // 加上Send + Sync约束，适配异步/多线程场景
    map: HashMap<TypeId, Arc<dyn Any + Send + Sync>>,
}

impl HeterogeneousStorage {
    // 约束T满足Send + Sync，确保RwLock包裹后整体符合要求
    pub fn add<T: 'static + Send + Sync>(&mut self, item: Arc<RwLock<GenericType<T>>>) -> &mut Self {
        let ty = TypeId::of::<T>();
        self.map.insert(ty, item);
        self
    }
    
    pub fn retrieve<T: 'static + Send + Sync>(&self) -> Arc<RwLock<GenericType<T>>> {
        self.map
            .get(&TypeId::of::<T>())
            .map(|item| {
                // 直接downcast为Arc<RwLock<GenericType<T>>>
                item.downcast::<RwLock<GenericType<T>>>()
                    .expect("downcast failed")
            })
            .unwrap_or_else(|| panic!("tried to retrieve {} but it was not added", type_name::<T>()))
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn downcasts_correctly() {
        struct Test;
        struct Test2;
        let mut store = HeterogeneousStorage {
            map: HashMap::new()
        };
        let t1 = Arc::new(RwLock::new(GenericType(Test)));
        let t2 = Arc::new(RwLock::new(GenericType(Test2)));
        store.add(t1.clone());
        store.add(t2.clone());
        
        assert!(Arc::ptr_eq(&t1, &store.retrieve::<Test>()));
        assert!(Arc::ptr_eq(&t2, &store.retrieve::<Test2>()));
        
    }
}

关键注意点 #

• Rc<dyn Any>/Arc<dyn Any>的底层类型是你传入的被包裹的类型，而非智能指针本身，不要混淆两者的类型层级。
• downcast方法是智能指针（Rc/Arc）提供的专门用于dyn Any转型的方法，比downcast_ref再克隆更高效，语义也更准确。
• 多线程场景下，必须确保dyn Any加上Send + Sync约束，同时存储的具体类型也需要满足这两个trait（Arc本身满足，RwLock满足的前提是内部类型满足）。

内容的提问来源于stack exchange，提问作者Taxel