有很多地方(包括here)显示如何使用Renderscript模糊图像,如下所示：

@TargetApi(VERSION_CODES.JELLY_BEAN_MR1)
public static Bitmap renderScriptBlur(Context context,Bitmap srcBitmap,@FloatRange(from = 0.0f,to = 25.0f) float radius) {
    if (srcBitmap == null)
        return null;
    Bitmap outputBitmap = null;
    RenderScript rs = null;
    try {
        rs = RenderScript.create(context);
        outputBitmap = Bitmap.createBitmap(srcBitmap.getWidth(),srcBitmap.getHeight(),Bitmap.Config.ARGB_8888);
        final Canvas canvas = new Canvas(outputBitmap);
        canvas.drawBitmap(srcBitmap,null);
        Allocation overlayAlloc = Allocation.createFromBitmap(rs,outputBitmap);
        ScriptIntrinsicBlur blur = ScriptIntrinsicBlur.create(rs,Element.U8_4(rs));
        blur.setInput(overlayAlloc);
        blur.seTradius(radius);
        blur.forEach(overlayAlloc);
        overlayAlloc.copyTo(outputBitmap);
        return outputBitmap;
    } catch (Exception ex) {
        if (outputBitmap != null)
            outputBitmap.recycle();
        return srcBitmap;
    } finally {
        if (rs != null)
            rs.destroy();
    }
}

问题

通常它工作得很好,但是当使用一些图像和/或半径设置时,输出图像具有看起来像扫描线的工件：

我试过的

我发现有一个更好的模糊解决方案(如here),但它们不使用Renderscript,也很慢并且耗费内存.

我也尝试使输入图像更小,但输出仍然有扫描线伪像.

最后,我还报道了这个,here.

这个问题

是否有可能使用Renderscript模糊图像而没有那些Artifcats？我写的是什么问题？

private static final atomicreference<RenderScript> sRenderscript = new atomicreference<>();


public static Bitmap blur(Context context,Bitmap bitmap) {
    return blur(context,bitmap,4,false,false);
}

public static Bitmap blur(Context context,Bitmap bitmap,float radius) {
    return blur(context,radius,Bitmap bitmapOriginal,to = 25.0f) float radius,boolean overrideOriginal,boolean recycleOriginal) {
    if (bitmapOriginal == null || bitmapOriginal.isRecycled())
        return null;
    RenderScript rs = sRenderscript.get();
    if (rs == null)
        if (!sRenderscript.compareAndSet(null,rs = RenderScript.create(context)) && rs != null)
            rs.destroy();
        else
            rs = sRenderscript.get();
    final Bitmap inputBitmap = bitmapOriginal.getConfig() == Config.ARGB_8888 ? bitmapOriginal : bitmapOriginal.copy(Config.ARGB_8888,true);
    final Bitmap outputBitmap = overrideOriginal ? bitmapOriginal : Bitmap.createBitmap(bitmapOriginal.getWidth(),bitmapOriginal.getHeight(),Config.ARGB_8888);
    final Allocation input = Allocation.createFromBitmap(rs,inputBitmap);
    final Allocation output = Allocation.createTyped(rs,input.getType());
    final ScriptIntrinsicBlur script = ScriptIntrinsicBlur.create(rs,Element.U8_4(rs));
    script.seTradius(radius);
    script.setInput(input);
    script.forEach(output);
    if (recycleOriginal && !overrideOriginal)
        bitmapOriginal.recycle();
    output.copyTo(outputBitmap);
    return outputBitmap;
}

现在一切顺利.

Person1 { get; set; }
Person2 { get; set; }
Person3 { get; set; }

我不想在类的实例上获取MethodInfo对象,而是执行类似这样的操作：

...
il.Emit(OpCodes.Callvirt,[instance]["set_Person" + index]);

上面的代码行是说明性的,而不是我认为它应该是什么.

有谁知道我怎么能这样做？

这似乎不是一个复杂的选择：

il.Emit(OpCodes.Callvirt,type.getmethod("set_Person" + index));

但是,在我的测试中,我需要发送一个命令,然后在继续测试之前等待(第一个)响应.

响应使用RX发布,我的第一次尝试代码是这样的：

service.SendCommand("BLAH");
await service.Responses.FirstAsync();

这个问题是,FirstAsync只有在响应到来之后才能工作,等待已经被打了.如果服务流程非常快,那么测试就会等待着.

我的下一次尝试解决这个问题是在发送命令之前调用FirstAsync(),以便即使在等待之前到达,也会产生结果：

var firstResponse = service.Responses.FirstAsync();
service.SendCommand("BLAH");
await firstResponse;

然而,这仍然以同样的方式失败.似乎只有当等待命中(GetAwaiter被调用)它才开始收听;所以存在完全相同的竞争条件.

如果我将主题改为具有缓冲区(或计时器)的ReplaySubject,那么我可以“解决”这个;然而在我的生产课上这样做是没有意义的;它只会用于测试.

在RX中能做到这一点的“正确”方法是什么？如何设置一个将不会引入竞争条件的方式在流上接收第一个事件的东西？

这是一个小测试,以“单线程”的方式说明问题.这个测试会不定期地停止：

[Fact]
public async Task Mytest()
{
    var x = new Subject<bool>();

    // Subscribe to the first bool (but don't await it yet)
    var firstBool = x.FirstAsync();

    // Send the first bool
    x.OnNext(true);

    // Await the task that receives the first bool
    var b = await firstBool; // <-- hangs here; presumably because firstBool didn't start monitoring until GetAwaiter was called?


    Assert.Equal(true,b);
}

我甚至尝试在我的测试中调用Replay(),它会缓冲结果;但这并不改变任何事情：

[Fact]
public async Task Mytest()
{
    var x = new Subject<bool>();

    var firstBool = x.Replay();

    // Send the first bool
    x.OnNext(true);

    // Await the task that receives the first bool
    var b = await firstBool.FirstAsync(); // <-- Still hangs here


    Assert.Equal(true,b);
}

[Fact]
public async Task Mytest()
{
    var x = new Subject<bool>();

    var firstBool = x.FirstAsync().PublishLast(); // PublishLast wraps an AsyncSubject
    firstBool.Connect();

    // Send the first bool
    x.OnNext(true);

    // Await the task that receives the first bool
    var b = await firstBool;


    Assert.Equal(true,b);
}

AsyncSubject基本上缓存在调用OnComplete之前的最后接收的值,然后重播它.