相关疑难解决方法(0)

有人能举例说明在C#代码中实际使用"不安全"和"修复"的好时机吗？我以前玩过它,但从来没有真正找到它的好用.

考虑这段代码......

fixed (byte* pSrc = src, pDst = dst) {
    //Code that copies the bytes in a loop
}

与简单使用...相比

Array.Copy(source, target, source.Length);

第二个是.NET Framework中的代码,第一部分是从Microsoft网站复制的代码,http://msdn.microsoft.com/en-us/library/28k1s2k6(VS.80).aspx.

内置的Array.Copy()比使用Unsafe代码要快得多.这可能只是因为第二个只是更好的编写,第一个只是一个例子,但你真的甚至需要使用不安全/固定代码的什么样的情况？或者,这个可怜的网络开发人员是否在弄乱他的头脑？

我正在使用以下项目,以便在服务器和客户端套接字之间创建异步通信.当我运行这些项目时,我正在从客户端向服务器发送消息,因此我收到了消息:

数据:记录EOF,向客户端发送14个字节.

我想要实现的是使用套接字从服务器向客户端发送布尔变量.这样做是否可行,我想知道因为在代码中我有等待和监听的服务器以及发送数据的客户端,我可以这样做吗？一般来说,我想要的是向几个客户端发送一个布尔值.为什么我需要文件结束才能发送字符串？是否有必要将所有内容转换为字符串？

编辑:一般来说,我想要的是将一个变量从一台计算机发送到另外两台,以便在所有计算机上同时开始一个过程.事实上,要创建一个切换器,它可以同时在2-3台机器上发出信号.

我尝试将以下代码用于服务器:

class Program
{
    const int PORT_NO = 2201;
    const string SERVER_IP = "127.0.0.1";
    static void Main(string[] args)
    {
        //---listen at the specified IP and port no.---
        IPAddress localAdd = IPAddress.Parse(SERVER_IP);
        TcpListener listener = new TcpListener(localAdd, PORT_NO);
        Console.WriteLine("Listening...");
        listener.Start();
        //---incoming client connected---
        TcpClient client = listener.AcceptTcpClient();
        //---get the incoming data through a network stream---
        NetworkStream nwStream = client.GetStream();
        byte[] buffer = new byte[client.ReceiveBufferSize];
        //---read incoming stream---
        int bytesRead = …

我使用Microsoft.Office.Interop.Excel我返回一个object[,]包含double元素的2D数组类型.请注意,索引下限1不是默认值0,但我可以轻松处理.

如何很好地将数组转换为double[,]使用.NET 3.5.(很好地,我的意思是简洁,或紧凑).

注意

double[] values_2 = values.Cast<double>().ToArray();

确实有效,但它通过阵列变平为一维结构.

要使用另一个数组创建和初始化数组,我目前执行此操作:

void Foo( int[] a )
{
    int[] b = new int[ a.Length ];
    for ( int i = 0; i < a.Length; ++i )
        b[ i ] = a[ i ];

    // Other code ...
}

在C#中使用更短或更惯用的方法吗？

如果可以在单个语句中完成,例如在C++中,那将是很好的:

vector<int> b( a );

如果这不能在一个声明中完成,我将采取我得到的:-)

可能重复:
C#:任何更快的复制数组的方法？

我有一个整数数组

int[] a;

我想指定它的副本(不是引用)

int[] b;

什么是更简单的方法呢？

我有一个包含int []数组的C#类(以及其他几个字段,但数组是主要的).代码经常创建此类的副本,并且分析显示复制此数组的Array.Copy()调用需要花费大量时间.我该怎么做才能让它更快？

数组大小非常小且恒定:12个元素.理想情况下,我喜欢类似C风格的数组:类本身内部的单个内存块(不是指针).这可能在C#中吗？(如果需要,我可以使用不安全的代码.)

我已经尝试过了:

1)使用UIn64和位移代替数组.(每个元素的值也非常小.)这确实使复制速度快,但整体上减慢了程序的速度.

2)为每个数组元素使用单独的字段:int element0,int element1,int element2等.同样,当我必须访问给定索引处的元素时,这总体上较慢.

可能的重复：
C#：复制数组的任何更快的方法？

我有一个像这样的结构数组：

struct S
{
    public long A;
    public long B;
}

...
S[] s1 = new S[1000000];
...
S[] = new S[s1.Length];
// Need to create a copy here.

我可以使用不安全模式并将结构的源数组复制到字节数组，然后从字节数组复制到结构的目标数组。但这意味着我将不得不分配一个巨大的中间字节数组。有没有办法避免这种情况？是否有可能以某种方式将目标数组表示为字节数组并直接复制到那里？

unsafe
{
    int size = Marshal.SizeOf(s0[0]) * s0.Length;
    byte[] tmp = new byte[size];
    fixed (var tmpSrc = &s0[0])
    {
        IntPtr src = (IntPtr)tmpSrc;
        Marchal.Copy(tmpSrc, 0, tmp, 0, size);
    }

    // The same way copy to destination s1 array...
}

会是怎样一个快速的方法来拷贝/转换一个array的Color32[]值的byte[]缓冲？ Color32是Unity 3D中包含的结构4 bytes, R, G, B and A respectively。我要完成的工作是将渲染的图像从整体通过管道发送到另一个应用程序（Windows Forms）。目前，我正在使用以下代码：

private static byte[] Color32ArrayToByteArray(Color32[] colors)
{
    int length = 4 * colors.Length;
    byte[] bytes = new byte[length];
    IntPtr ptr = Marshal.AllocHGlobal(length);
    Marshal.StructureToPtr(colors, ptr, true);
    Marshal.Copy(ptr, bytes, 0, length);
    Marshal.FreeHGlobal(ptr);
    return bytes;
}

谢谢，抱歉，我是StackOverflow的新手。Marinescu Alexandru

我有服务器和客户端控制台应用程序，它们可以正常通信并发送一些字符串。这是代码...

服务器

public static void Main()
    {
        try
        {
            IPAddress ipAd = IPAddress.Parse("127.0.0.1"); 

            /* Initializes the Listener */
            TcpListener myList = new TcpListener(ipAd, 1234);

            /* Start Listeneting at the specified port */
            myList.Start();

            Console.WriteLine("The server is running at port 8001...");
            Console.WriteLine("The local End point is  :" + myList.LocalEndpoint);
            Console.WriteLine("Waiting for a connection.....");

            Socket s = myList.AcceptSocket();
            Console.WriteLine("Connection accepted from " + s.RemoteEndPoint);

            byte[] b = new byte[100];
            int k = s.Receive(b);
            Console.WriteLine("Recieved...");
            for (int i = 0; i < k; …

我有一个共有5000个元素的数组,在一个功能中,我只需要最后3000个元素才能继续进行.

为此,我尝试了以下解决方案.

//skipping first 2000 elements
list = list.Skip(5000 - 3000).ToArray();

这个解决方案实际上给了我想要的解决方案,但是当我在我的代码上运行分析器时,它在这一行显示了大量的内存分配.

由于遗留下来,我必须使用Array.并且非常频繁ToArray()似乎对性能没有好处.

还有可能的解决方案,

//reversing whole list
Array.Reverse(list);
//restricting size of an array to 3000,
//so first (as reversed the list, they are last 3000 elements) 
Array.Resize(ref list, 3000);
//again reversing list to make it proper order
Array.Reverse(list);

但是时间复杂度更差.

有没有更好的解决方案,不需要从List到Array？