标签: lifetime-scoping

Rust有一个与非词汇生命周期相关的RFC,已被批准在该语言中实现了很长时间.最近,Rust对此功能的支持有了很大改进,并且被认为是完整的.

我的问题是:非词汇生命究竟是什么？

如果我有这两个功能

// implicit
fn foo(x: &i32) {
}

// explicit
fn bar<'a>(x: &'a i32) {
}

何时会foo返回错误并bar成为正确的函数头？我很困惑为什么我会明确地声明一生:

'a读'生命'a'.从技术上讲,每个引用都有一些与之相关的生命周期,但编译器允许您在常见情况下忽略它们.

我明白一生是什么,但明确指定一生的'a 事情对我有什么影响？作为参考,我使用Rust书作为阅读材料

我正在使用 Mediatr 处理来自队列的消息。我可以得到一个简单的例子来工作。但是，当我尝试将对象注入我的处理程序时遇到了问题

public class MessageCommandHandler : IRequestHandler<MessageCommand, bool>
    {
        private IMyDependency myDependency;
        public MessageCommandHandler(IMyDependency myDependency)
        {
            this.myDependency = myDependency;
        }

        public Task<bool> Handle(MessageCommand request, CancellationToken cancellationToken)
        {
            return Task.FromResult(true);
        }
    }

这仅在我将 IMyDependency 注册为临时作用域时才有效，但是当我将其注册为作用域生命周期时，它会失败并显示错误

Cannot resolve 'MediatR.IRequestHandler`2[MyNamespace.MessageCommand,System.Boolean]' from root provider because it requires scoped service 'MyNamespace.IMyDependency'

我需要能够注入具有范围生命周期的依赖项。有没有人对此有解决方案。

我正在使用 .NET Core 依赖注入框架。设置如下

services.AddHostedService<QueueConsumer>();
services.AddScoped<IMyDependency, MyDependency>();
services.AddMediatR(new Assembly[] { Assembly.GetExecutingAssembly() });

有任何想法吗？

我正在使用带有MVC4附加组件的Autofac IoC容器,该附加组件提供InstancePerHttpRequest生命周期范围.但是在我的项目中,我有web,web-api和后台工作线程.在下面的示例中,我假设InstancePerHttpRequest范围在不是源自Web请求时并不重要.

builder.RegisterType<DatabaseFactory>().As<IDatabaseFactory>()
    .InstancePerHttpRequest()

我想知道是否有可能做类似下面的例子并让容器选择最合适的生命周期范围？

builder.RegisterType<DatabaseFactory>().As<IDatabaseFactory>()
    .InstancePerHttpRequest()
    .InstancePerApiRequest()
    .InstancePerDependency();

在这种情况下,我打算发生的是,如果请求来自Web请求,那么它将选择InstancePerHttpRequest范围,如果它来自webApi请求,它将选择InstancePerApiRequest范围,如果它被应用程序工作线程使用,它将使用InstancePerDependency范围？

任何想法,如果这或类似的东西是可能的？
谢谢

Box<Fn() + Send + 'static>生锈意味着什么？

我在阅读高级类型章节时偶然发现了这种语法.Send是一种特质,但对于类型参数化中+的特征('static在这种情况下)的生命周期是什么意思？还有什么Fn()？

我目前正在Rust(1.0)的生命中挣扎,特别是在通过通道传递结构时.

我将如何编译这个简单的例子:

use std::sync::mpsc::{Receiver, Sender};
use std::sync::mpsc;
use std::thread::spawn;
use std::io;
use std::io::prelude::*;

struct Message<'a> {
    text: &'a str,
}

fn main() {
    let (tx, rx): (Sender<Message>, Receiver<Message>) = mpsc::channel();

    let _handle_receive = spawn(move || {
        for message in rx.iter() {
            println!("{}", message.text);
        }
    });

    let stdin = io::stdin();
    for line in stdin.lock().lines() {
        let message = Message {
            text: &line.unwrap()[..],
        };
        tx.send(message).unwrap();
    }
}

我明白了:

error[E0597]: borrowed value does not live long enough
  --> src/main.rs:23:20
   |
23 |             text: …

要访问DocumentDB/CosmosDB,我正在使用包Microsoft.Azure.DocumentDB.Core(v1.3.2).当我创建并初始化DocumentClient类时,我注意到了:

var documentClient = new DocumentClient(new Uri(endpointUrl), primaryKey);
await documentClient.OpenAsync();

向端点发出了许多请求以获取有关索引和其他信息的信息.确切地说,有9个HTTP请求正在进行中.OpenAsync().这使得客户端的创建和激活在性能方面成本非常高 - 需要一秒钟才能将所有请求带回家.

因此,为了减轻这种代价高昂的操作,我正在制作DocumentClient一个单例,并在应用程序的生命周期内保持参考.

应用程序是Asp.Net Core MVC,这可能会将此对象的引用保留在内存中数天.

问题:可以将此对象保持为单例吗？如果不是,应该采取什么策略来处置它？或者有没有办法使初始化更便宜(即不要做出这些初始请求？).

我想在Autofac中为每个匹配的生命周期范围注册创建一个实例,但偶尔需要从全局容器(没有匹配的生命周期范围)请求实例.在没有匹配的生命周期范围的情况下,我想提供一个顶级实例而不是抛出异常.

这可能吗？

我有两个对象,第二个对象要求第一个对象比它更长,因为它包含对第一个对象的引用.我需要将它们都移动到一个线程中,但编译器抱怨第一个没有足够长的时间.这是代码:

use std::thread;

trait Facade: Sync {
    fn add(&self) -> u32;
}

struct RoutingNode<'a> {
    facade: &'a (Facade + 'a),
}

impl<'a> RoutingNode<'a> {
    fn new(facade: &'a Facade) -> RoutingNode<'a> {
        RoutingNode { facade: facade }
    }
}

fn main() {
    struct MyFacade;

    impl Facade for MyFacade {
        fn add(&self) -> u32 {
            999u32
        }
    }

    let facade = MyFacade;
    let routing = RoutingNode::new(&facade);

    let t = thread::spawn(move || {
        let f = facade;
        let r = routing;
    });

    t.join(); …

具有一个静态引用的异步函数编译：

pub async fn test_0(_a: &'static str)  {
}

具有非静态和静态引用的异步函数编译：

pub async fn test_1<'a>(_a: &'a str, _b: &'static str)  {
}

具有三个非静态引用的异步函数编译：

pub async fn test_2<'a, 'b, 'c>(_a: &'a str, _b: &'b str, _c: &'c str)  {
}

接受两个非静态引用和一个静态引用并返回未来编译的函数：

pub fn test_3_desugared<'a, 'b>(_a: &'a str, _b: &'b str, _c: &'static str) -> impl std::future::Future<Output=()> {
  std::future::ready(())
}

那么为什么采用两个非静态引用和一个静态引用的异步函数无法编译呢？

pub async fn test_3<'a, 'b>(_a: &'a str, _b: &'b str, _c: &'static str)  {
}

有问题的编译错误：

error[E0700]: hidden type for …