标签: unsafe

今天阅读这个关于安全和不安全代码的问题我然后在MSDN中阅读它,但我仍然不理解它.你为什么要在C#中使用指针？这纯粹是为了速度吗？

我想知道VB.NET相当于以下C#代码:

    unsafe
    {
        byte* pStart = (byte*)(void*)writeableBitmap.BackBuffer;
        int nL = writeableBitmap.BackBufferStride;

        for (int r = 0; r < 16; r++)
        {
            for (int g = 0; g < 16; g++)
            {
                for (int b = 0; b < 16; b++)
                {
                    int nX = (g % 4) * 16 + b;                            
                    int nY = r*4 + (int)(g/4);

                    *(pStart + nY*nL + nX*3 + 0) = (byte)(b * 17);
                    *(pStart + nY*nL + nX*3 + 1) = (byte)(g * 17);
                    *(pStart …

我前几天穿过sun.misc.Unsafe包,惊讶于它能做些什么.它的存在给我留下了一些问题.

有没有充分的理由使用不安全的包裹？或许更具体的问题是,您可能需要它的情况.如果你确实需要它,那是不是说明你的设计可能有问题呢？为什么甚至包括在内？

Pipes当有多个发送者和接收者时,我不明白为什么说不安全.

Queues如果是这种情况,如何将以下代码转换为代码？关闭时Queues不要抛出EOFError,所以我的进程无法停止.我是否应该无休止地发送"Poison"消息告诉他们停止(这样,我确定我的所有进程都至少收到一个毒药)？

我想保持管道p1打开,直到我另有决定(这是我发送10条消息的时候).

from multiprocessing import Pipe, Process
from random import randint, random
from time import sleep

def job(name, p_in, p_out):
    print(name + ' starting')
    nb_msg = 0
    try:
        while True:
            x = p_in.recv()
            print(name + ' receives ' + x)
            nb_msg = nb_msg + 1
            p_out.send(x)
            sleep(random())
    except EOFError:
        pass
    print(name + ' ending ... ' + str(nb_msg) + ' message(s)')

if __name__ == '__main__':
    p1_in, p1_out = Pipe()
    p2_in, p2_out …

据我所知,根据MSDN C#fixed语句应该像:

fixed (char* p = str) ... // equivalent to p = &str[0]

所以,为什么我不能这样做？

    const string str = "1234";
    fixed (char* c = &str[0])
    {
/// .....
    }

str[1]作为一个例子,我怎样才能得到指针？

实验

我尝试了下面的代码片段Spark 1.6.1.

val soDF = sqlContext.read.parquet("/batchPoC/saleOrder") # This has 45 files
soDF.registerTempTable("so")
sqlContext.sql("select dpHour, count(*) as cnt from so group by dpHour order by cnt").write.parquet("/out/")

该Physical Plan方法是:

== Physical Plan ==
Sort [cnt#59L ASC], true, 0
+- ConvertToUnsafe
   +- Exchange rangepartitioning(cnt#59L ASC,200), None
      +- ConvertToSafe
         +- TungstenAggregate(key=[dpHour#38], functions=[(count(1),mode=Final,isDistinct=false)], output=[dpHour#38,cnt#59L])
            +- TungstenExchange hashpartitioning(dpHour#38,200), None
               +- TungstenAggregate(key=[dpHour#38], functions=[(count(1),mode=Partial,isDistinct=false)], output=[dpHour#38,count#63L])
                  +- Scan ParquetRelation[dpHour#38] InputPaths: hdfs://hdfsNode:8020/batchPoC/saleOrder

对于这个查询,我有两个工作:Job 9和Job 10

因为Job 9,DAG是:

因为 …

我只是用C#做了一个Swap例程:

static void Swap(ref int x, ref int y)
{
    int temp = x;
    x = y;
    y = temp;
}

它与C++代码的作用相同:

void swap(int *d1, int *d2)
{
    int temp=*d1;
    *d1=*d2;
    *d2=temp;
}

所以是ref和out关键字,比如C#的指针,而无需使用unsafe代码？

我正在寻找一种方法来过滤出unsafe通过反射具有修饰符的方法.它似乎不是方法属性.

有办法吗？

编辑:似乎这个信息不在元数据中,至少我在IL中看不到它.但是反射unsafe器在C#视图中显示修改器.关于它是如何完成的任何想法？

编辑2:根据我的需要,我最终得到了一个检查,假设如果方法的某个参数是指针,或者返回类型是指针,那么该方法是不安全的.

    public static bool IsUnsafe(this MethodInfo methodInfo)
    {
        if (HasUnsafeParameters(methodInfo))
        {
            return true;
        }

        return methodInfo.ReturnType.IsPointer;
    }

    private static bool HasUnsafeParameters(MethodBase methodBase)
    {
        var parameters = methodBase.GetParameters();
        bool hasUnsafe = parameters.Any(p => p.ParameterType.IsPointer);

        return hasUnsafe;
    }

当然,这不会处理在方法中执行不安全块的情况,但同样,我感兴趣的是方法签名.

谢谢!

msbuild似乎不允许我构建unsafe块,即使我.csproj指定:

<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
    ...
    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
</PropertyGroup>

我的构建命令是:

msbuild myProject.sln /p:Configuration=Release /p:Platform="Any CPU" /t:Clean,Build

我正在编写一些不安全的Rust代码，因此我需要知道*const T和之间的确切区别*mut T。我以为是&T和&mut T（即，您T不能通过&T，句号进行变异），但事实并非如此！

例如，指针包装器NonNull<T>的定义如下（source）：

pub struct NonNull<T: ?Sized> {
    pointer: *const T,
}

但是，可以*mut T通过as_ptr定义从以下包装器获取一个：

pub const fn as_ptr(self) -> *mut T {
    self.pointer as *mut T
}

该功能甚至没有标记为unsafe！我不允许强制从转换&T为&mut T（出于充分的理由！），但显然像这样强制转换指针是可以的。

该Nomicon提到了关于方差章是*const T和*mut T方差有所不同：

• *const T：协变
• *mut T：不变的

这是指针类型之间的唯一区别吗？在我看来，这很奇怪。

指针类型之间到底有什么区别？是否有限制，*const T那*mut T …