Los punteros y los almacenamientos intermedios de tamaño fijo solo se pueden usar en un contexto inseguro

Question

Tengo 2 funciones dentro de una clase y obtengo un error en la llamada para la función ParseBits() es decir "int num_elements = ParseBits(bits, buffer);" debido al argumento "buffer" que estoy aprobando "public int ParseBits(string bits, int* buffer) ":

Función 1:

public float AssignFitness(string bits, int target_value) 
     { 

    //holds decimal values of gene sequence 
    int[] buffer = new int[(VM_Placement.AlgorithmParameters.chromo_length/VM_Placement.AlgorithmParameters.gene_length)]; 

    int num_elements = ParseBits(bits, buffer); 

    // ok, we have a buffer filled with valid values of: operator - number - operator - number.. 
    // now we calculate what this represents. 
    float result = 0.0f; 

    for (int i=0; i < num_elements-1; i+=2) 
    { 
     switch (buffer[i]) 
     { 
     case 10: 

      result += buffer[i+1]; 
      break; 

     case 11: 

      result -= buffer[i+1]; 
      break; 

     case 12: 

      result *= buffer[i+1]; 
      break; 

     case 13: 

      result /= buffer[i+1]; 
      break; 

     }//end switch 

    } 

    // Now we calculate the fitness. First check to see if a solution has been found 
    // and assign an arbitarily high fitness score if this is so. 

    if (result == (float)target_value) 

     return 999.0f; 

    else 

     return 1/(float)fabs((double)(target_value - result)); 
    // return result; 
} 

Función 2:

public int ParseBits(string bits, int* buffer) 
     { 

      //counter for buffer position 
      int cBuff = 0; 

      // step through bits a gene at a time until end and store decimal values 
      // of valid operators and numbers. Don't forget we are looking for operator - 
      // number - operator - number and so on... We ignore the unused genes 1111 
      // and 1110 

      //flag to determine if we are looking for an operator or a number 
      bool bOperator = true; 

      //storage for decimal value of currently tested gene 
      int this_gene = 0; 

      for (int i = 0; i < VM_Placement.AlgorithmParameters.chromo_length; i += VM_Placement.AlgorithmParameters.gene_length) 
      { 
       //convert the current gene to decimal 
       this_gene = BinToDec(bits.Substring(i, VM_Placement.AlgorithmParameters.gene_length)); 

       //find a gene which represents an operator 
       if (bOperator) 
       { 
        if ((this_gene < 10) || (this_gene > 13)) 

         continue; 

        else 
        { 
         bOperator = false; 
         buffer[cBuff++] = this_gene; 
         continue; 
        } 
       } 

       //find a gene which represents a number 
       else 
       { 
        if (this_gene > 9) 

         continue; 

        else 
        { 
         bOperator = true; 
         buffer[cBuff++] = this_gene; 
         continue; 
        } 
       } 

      }//next gene 

      // now we have to run through buffer to see if a possible divide by zero 
      // is included and delete it. (ie a '/' followed by a '0'). We take an easy 
      // way out here and just change the '/' to a '+'. This will not effect the 
      // evolution of the solution 
      for (int i = 0; i < cBuff; i++) 
      { 
       if ((buffer[i] == 13) && (buffer[i + 1] == 0)) 

        buffer[i] = 10; 
      } 

      return cBuff; 
     } 

estoy consiguiendo 2 errores para estas funciones en la línea resaltada s:

Error 1: The best overloaded method match for 'VM_Placement.Program.ParseBits(string, int*)' has some invalid arguments 

Error 2: Pointers and fixed size buffers may only be used in an unsafe context 

Answer 1

Tal vez me he perdido, pero que no parece estar haciendo nada que realmente requiere el uso de un int*. ¿Por qué no simplemente pasar un array int y cambiar la firma de la función ParseBits a:

public int ParseBits(string bits, int[] buffer)

y retire los bloques unsafe{ ... } por completo.

Answer 2

Es necesario incluir su función utilizando punteros primas en un bloque unsafe.

unsafe 
{ 
//your code 
} 

Answer 3

Tuve el mismo problema, pero no fue resuelto por ninguna de las otras respuestas aquí. Seguí recibiendo diferentes errores.

Cualquier función que use código inseguro simplemente necesita ser declarada con la palabra clave "inseguro".
Por ejemplo:

static unsafe void myFunction(int* myInt, float* myFloat) 
{ 
    // Function definition 
} 

En lo personal, yo estaba tratando de hacer esto al hacer una clase contenedora.
Para los interesados, que terminó buscando algo como esto:

using System.Runtime.InteropServices; 

namespace myNamespace 
{ 
    public class myClass 
    { 
     [DllImport("myLib.so", EntryPoint = "myFunction")] 
     public static extern unsafe void myFunction(float* var1, float* var2); 
    } 
} 

Hay una gran cantidad de información en el "Código Tutorial inseguro" MSDN:
https://msdn.microsoft.com/en-us/library/aa288474(v=vs.71).aspx

es probablemente vale la pena leer, me lo encontré bastante útil.