小编Che*_*vas的帖子

注意:我不是一个专业的软件开发人员,但是我写了很多不使用异步的代码,所以如果这个问题真的很直接,我很抱歉.

我正在与用C#编写的库连接.有一个特殊的函数(让我们称之为'func')返回'Threading.Tasks.Task>'

我正在使用func在F#中构建一个库.我在控制台应用程序中测试了以下代码,它工作正常.

let result = 
        func()
        |> Async.AwaitTask
        |> Async.RunSynchronously
        |> Array.ofSeq

但是,当我从WinForms应用程序运行它(这最终是我想要做的)时,表单代码中的执行块永远不会返回.

所以我搞乱了代码,并尝试了以下,这是有效的.

let result = 
        async{
            let! temp = 
                func()
                |> Async.AwaitTask

            return temp
        } |> Async.RunSynchronously |> Array.ofSeq

为什么第一个片段不起作用？为什么第二个片段有效？这个页面上有什么内容可以回答这些问题吗？如果是这样,那似乎并不明显.如果没有,你能指点我到哪儿吗？

只需浏览本教程：https : //www.davepaquette.com/archive/2019/02/06/managing-transactions-in-dapper.aspx

我的理解（没有 Dapper）是一旦你有一个连接，你可以打开一个事务，然后执行一堆语句，然后提交或回滚事务。这些查询不需要引用事务，因为连接已经“知道”了它。

那么为什么每次执行某些操作时，Dapper 都需要事务？

我一直在VBA开发办公室解决方案已有一段时间了,并且对VBA中的办公室开发有相当完整的了解.我已经决定是时候用.Net学习一些真正的编程了,并且遇到了一些问题.

浏览了大量文章和论坛(此处和其他地方),在使用COM对象时,似乎有一些关于.Net内存管理的混合信息.

有人说我应该总是确定性地释放COM对象,而其他人说我几乎不应该这样做.

人们说我应该这样做:

第861页的"专业Excel开发"一书.

这个堆栈交换问题已经回答说"必须释放你对COM对象的每个引用.如果你没有,那么进程将留在内存中"

这篇博客建议使用它来解决他的问题.

人们说我不应该这样做:

这篇由Eric Carter撰写的MSDN博客指出"在VSTO场景中,您通常不必使用ReleaseCOMObject."

由Eric Carter共同撰写的"VSTO for Office 2007"这本书似乎没有提及任何内存管理或ReleaseComObject.

这篇由Paul Harrington撰写的MSDN博客说不要这样做.

有混合建议的人:

Jake Ginnivan说我应该总是在没有离开方法范围的COM对象上做这件事.如果COM对象离开方法范围,则忘记它.为什么我不能一直忘记它呢？

Paul Harrington的博客似乎暗示MS的建议在过去的某个时候发生了变化.调用ReleaseCOMObject曾经是最佳实践,但现在不是了吗？我可以将更精细的内存管理细节留给MS,并假设一切都很好吗？

通过本教程，我正在自学CNTK 。

有一个功能定义为

def linear_layer(input_var, output_dim):

    input_dim = input_var.shape[0]
    weight_param = C.parameter(shape=(input_dim, output_dim))
    bias_param = C.parameter(shape=(output_dim))

    mydict['w'], mydict['b'] = weight_param, bias_param

    return C.times(input_var, weight_param) + bias_param

在线性代数中，将两个矩阵相乘时，只有内部尺寸匹配时才有意义。更明确地说，左侧的第二维必须等于右侧的第一维。

在此函数中，“ times”函数的第2个（右）参数为“ weight_param”，其第一个尺寸设置为与第一个（左）参数的第一个尺寸相同。这不会起作用，因为内部尺寸不匹配。

我不确定input_var是（nx 2）还是（2 xn），但是无论哪种方式都会导致错误。如果它是（nx 2），则weight_param是（nx 2）和（nx 2）*（nx 2）不应计算。如果为（2 xn），则weight_param为（2 x 2），并且不应计算（2 xn）*（2 x 2）。

但是以某种方式，它运行得很好。更令人困惑的是，如果我将函数的最后一行更改为

return C.times_transpose(input_var, weight_param) + bias_param

它产生exaclty相同的结果。

那么这是怎么回事？为什么这样做？为什么转置版本产生相同的结果？

PS：我正在与cntk同时教自己使用python，因此这些观察结果可能由python引起的。让我知道。

我正在学习一个Haskell,所以非常好.

对于F#我非常流利,我想尝试纯函数式编程.

我一直喜欢F#的一个特点是你的代码顺序很重要.您无法调用尚未定义的函数.这很有用,因为它可以保证早期的代码文件包含低级函数,后来的代码包含更大的图片.它迫使我现在认为是一件好事的结构.

Haskell似乎并不太关心代码顺序.虽然我可以选择构建我的代码,但我并没有被迫.所以在学习Haskell的早期阶段,我想知道是否有一些编译器选项强制这个？

该语言的建议指出，其优点是在链接的文件中详述。我快速浏览了一下，但看不到它的明确说明。

优点是每个语句都并行执行，所以我可能会得到速度提升？或者它是否满足某种逻辑，使用通常的 monadic 不方便let!？

我明白，这是适用的，这意味着它带有我不能使用以前的表达式来确定后续表达式的逻辑的限制。那么这是否意味着权衡是效率的灵活性？

我正在阅读Mark Seemann的这篇优秀文章.

在其中,他简单地演示了如何使用自由monad来使用纯函数来模拟交互.

我理解它足以能够编写这样的程序,我可以理解这种方法的优点.虽然有一点代码,但我想知道它的含义.

let rec bind f = function
    | Free instruction -> instruction |> mapI (bind f) |> Free
    | Pure x -> f x

该函数是递归的.

1. 鉴于这不是尾递归,这是否意味着我包含的指令数量受到堆栈空间的限制,因为每次我添加一条指令时,它必须打开整个东西才能添加它？
2. 与上述类似,这是否意味着更高的启动时间,因为每个新指令都需要进一步下载才能添加？它可能是微不足道的,但这不是问题的重点; 我试图理解这个理论,而不是实用性.
3. 如果上述问题的答案为"是",那么是否会有另一种实现方式(按照您希望的顺序列出指令列表,然后按相反的顺序处理列表,使每条指令都添加到顶部你的程序,而不是深入底部)更可取吗？

我可能(可能)错过了一些基本的东西,这意味着递归永远不会走得太远,请让我知道.

我正在使用规范 ECS 库，并且我有以下类型

trait TradeableResource{}

#[derive(Component)]
struct MarketMaker<T: TradeableResource + std::marker::Send + std::marker::Sync + 'static>{
    lot_size:T
}

如果没有约束，则无法编译'static。我最初担心这意味着这个结构体的所有值都必须在程序的整个生命周期中存在，但 环顾 四周，这种担心似乎是无效的。这些链接清楚地涉及该主题，但我觉得它们没有使用为我提供清晰的心理模型的语言。所以我想就这个话题发表我自己的声明，你告诉我我是否正确。

我的声明

通过使用'static约束，任何填充 位置的类型都T必须

#[derive(Component)]
struct Food(f64);
impl TradeableResource for Food{}

fn main() {
    let mut world = World::new();
    world.register::<MarketMaker<Food>>();

    world.create_entity().with(MarketMaker { lot_size: Food(4.0)}).build();
}