小编thr*_*thr的帖子

编辑:我很清楚这对于值类型非常有效,我的具体问题是将其用于引用类型.

Edit2:我也知道你不能在结构中覆盖引用类型和值类型,这只是为了将几个引用类型字段相互重叠.

我一直在修补.NET/C#中的结构,我发现你可以这样做:

using System;
using System.Runtime.InteropServices;

namespace ConsoleApplication1 {

    class Foo { }
    class Bar { }

    [StructLayout(LayoutKind.Explicit)]
    struct Overlaid {
        [FieldOffset(0)] public object AsObject;
        [FieldOffset(0)] public Foo AsFoo;
        [FieldOffset(0)] public Bar AsBar;
    }

    class Program {
        static void Main(string[] args) {
            var overlaid = new Overlaid();
            overlaid.AsObject = new Bar();
            Console.WriteLine(overlaid.AsBar);

            overlaid.AsObject = new Foo();
            Console.WriteLine(overlaid.AsFoo);
            Console.ReadLine();
        }
    }
}

基本上避免在运行时通过使用具有显式字段布局的结构进行动态转换,然后以正确的类型访问内部对象.

现在我的问题是:这是否会以某种方式导致内存泄漏,或CLR内部的任何其他未定义的行为？或者这是一个完全支持的约定,可以使用而没有任何问题？

我知道这是CLR的一个黑暗角落,而且这种技术在极少数特定情况下才是可行的选择.

我最初的问题是我需要在C#中实现一个非常快速的稀疏数组.最初的想法是使用法线Dictionary<uint, TValue>并将其包装在我自己的类中以仅显示TValue类型参数.事实证明这很慢.

所以我的下一个想法是将所需范围(UInt32.MinValueto UInt32.MaxValue)中的每个整数映射到某个大小的存储桶并使用它.所以我正在寻找一种将无符号整数X映射到桶Y的好方法,例如:

将数字0-1023映射到8个不同的桶,每个桶包含128个数字,0-127,128-255.

但是,如果某人有更好的方法在C#中实现快速稀疏数组,那么这也是最受欢迎的.

我正在尝试计算黑白图像像素的带符号距离场,但我想我已经设法在某处弄错了代码.因为这是我的输入和输出:

输入

产量

我遇到的问题是S中间的黑线,我的理解让我相信它应该是完全浅灰色的吗？

这是我正在使用的代码:

    for (int x = 0; x < source.width; ++x)
    {
        for(int y = 0; y < source.height; ++y) 
        {
            // Get pixel
            float a = source.GetPixel(x, y).r;

            // Distance to closest pixel which is the inverse of a
            // start on float.MaxValue so we can be sure we found something
            float distance = float.MaxValue;

            // Search coordinates, x min/max and y min/max
            int fxMin = Math.Max(x - searchDistance, 0);
            int fxMax = Math.Min(x + searchDistance, …

我有一个有两个点的图像,对齐如下:

|----------------|
|                |
|    .           |
|                |
|          .     |
|                |
|----------------|

我有两个点的X,Y坐标,我需要将图像旋转X度,所以它看起来像这样:

|----------------|
|                |
|                |
|    .     .     |
|                |
|                |
|----------------|

基本上所以他们在彼此旁边对齐,这是什么数学？(C#中的代码示例会更好但不是必需的)

所以我一直在阅读Apress的Expert F#书,主要是在构建一个玩具式的F#库时使用它作为参考,但有一件事我没有掌握,那就是"选项"类型.

它是如何工作的以及它的真实用途是什么？

我需要一个支持这些声明的多线程数据结构:

• 允许多个并发读者和作者
• 排序
• 容易推理

实现多个读者和一个作家要容易得多,但我真的不想允许多个作家.

我一直在研究这个领域,我知道ConcurrentSkipList(由Lea基于Fraser和Harris的工作),因为它是在Java SE 6中实现的.我还实现了我自己的并发Skip List版本在一个可证明正确的缩放并发跳表由赫利希,列弗,Luchangco和沙维特.

这两个实现是由比我更聪明的人开发的,但我仍然(有点惭愧,因为它是惊人的工作)不得不问这些问题是否是并发多读/写器数据结构的两个唯一可行的实现今天有空吗？

我只是把头包裹在monads周围(至少我想我有),更具体地说是状态monad,有些人比我想象的更聪明,所以我可能会回答这个问题.

无论如何,状态monad通常用M <a>实现,如下所示(F#):

type State<'a, 'state> = State of ('state -> 'a * 'state)

现在我的问题是:你有什么理由不能在这里使用元组吗？除此之外可能存在歧义MonadA<'a, 'b>,MonadB<'a, 'b>哪些都会成为等价('a * 'b)元组.

编辑:为清晰起见添加了示例

type StateMonad() =
  member m.Return a = (fun s -> a, s)
  member m.Bind(x, f) = (fun s -> let a, s_ = x s in f a s_)

let state = new StateMonad()
let getState = (fun s -> s, s)
let setState s = (fun _ -> (), s) 
let execute m …

我正在寻找String.Format()的格式说明符(或者如果有一个将要执行它的NumberFormatInfo类)在.NET中将整数格式化为八进制,将其 {0:x}格式化为十六进制,例如:

String.Format("{0:x}", 15) // returns "f"

在SO上有很多关于Interlockedvs 的问题volatile,我理解并且知道volatile(没有重新排序,总是从内存中读取等)的概念,并且我知道它是如何Interlocked工作的,它执行原子操作.

但我的问题是:假设我有一个从多个线程中读取的字段,这是一些引用类型,例如:public Object MyObject;.我知道,如果我这样做就可以了比较交流,是这样的:Interlocked.CompareExchange(ref MyObject, newValue, oldValue)即互锁担保,只写newValue该存储位置ref MyObject指的是,如果ref MyObject和oldValue目前指的是同一个对象.

但阅读呢？并Interlocked保证任何线程读取MyObject后CompareExchange成功将立即获得新的价值经营,或者我必须标记MyObject为volatile保证呢？

我想知道的原因是我已经实现了一个无锁链接列表,当你为它添加一个元素时,它会不断地更新其内部的"head"节点,如下所示:

[System.Diagnostics.DebuggerDisplay("Length={Length}")]
public class LinkedList<T>
{
    LList<T>.Cell head;

    // ....

    public void Prepend(T item)
    {
        LList<T>.Cell oldHead;
        LList<T>.Cell newHead;

        do
        {
            oldHead = head;
            newHead = LList<T>.Cons(item, oldHead);

        } while (!Object.ReferenceEquals(Interlocked.CompareExchange(ref head, newHead, oldHead), oldHead));
    }

    // ....
} …

我一直在尝试设计一个允许大量并发用户同时在内存中表示的系统.当我开始设计这个系统时,我立刻想到了某种基于actor的解决方案,这是Erlang的亲属.

系统必须在.NET中完成,所以我开始使用MailboxProcessor在F#中开发原型,但是遇到了严重的性能问题.我最初的想法是每个用户使用一个actor(MailboxProcessor)来为一个用户序列化通信通信.

我已经隔离了一小段代码,它重现了我所看到的问题:

open System.Threading;
open System.Diagnostics;

type Inc() =

    let mutable n = 0;
    let sw = new Stopwatch()

    member x.Start() =
        sw.Start()

    member x.Increment() =
        if Interlocked.Increment(&n) >= 100000 then
            printf "UpdateName Time %A" sw.ElapsedMilliseconds

type Message
    = UpdateName of int * string

type User = {
    Id : int
    Name : string
}

[<EntryPoint>]
let main argv = 

    let sw = Stopwatch.StartNew()
    let incr = new Inc()
    let mb = 

        Seq.initInfinite(fun id -> 
            MailboxProcessor<Message>.Start(fun inbox -> 

                let …