創建在C＃

Question

用於一結構的字節數組構件我具有這樣的結構定義如下：

public struct check 
{ 
    public int[] x = new int[3]; //error 
} 

這是一個錯誤，因爲你不能在C＃的結構部件限定的陣列大小。我不能爲C＃中的默認構造函數定義此數組的空間，因爲不允許使用無參數的構造函數。

我該怎麼做？我知道C＃中的結構是不可變的。

我使用這個結構不是爲了創建新的對象，而是爲了對其他類類型進行類型轉換。

check corp = (check)WmUtils.WM_GetObj(Attr); 

Wm_getObj返回check2類型的對象。 Readonly關鍵字在這裏有幫助嗎？

Answer 1

你不能有一個參數的構造函數，你不能定義與結構大小的數組，這個給你留下一個結構構造採取size像參數：

public struct check 
{ 
    public int[] x; 
    public check(int size) 
    { 
     x = new int[size]; 
    } 
} 

Answer 2

給出一個CHECK2類：

public class check2 
    { 
    public int x1 { get; set; } 
    public int x2 { get; set; } 
    public int x3 { get; set; } 
    } 

在你的帶有整型數組的結構中，只需添加一個運算符來從類中轉換它。操作員可以初始化從類實例的數組：

public struct check 
    { 
    public int[] x; 

    public static explicit operator check(check2 c2) 
    { 
     return new check() { x = new int[3] { c2.x1, c2.x2, c2.x3 } }; 
    } 
    } 

現在，您可以創建一個check2類，並將其轉換爲check結構：

check2 c2 = new check2() { x1 = 1, x2 = 2, x3 = 3 }; 
    check s = (check)c2; 
    Console.WriteLine(string.Format("{0}, {1}, {2}", s.x[0], s.x[1], s.x[2])); 

此輸出1, 2, 3

Answer 3

怎麼樣fixed array buffer：

public unsafe struct Buffer 
{ 
    const int Size=100; 
    fixed byte data[Size]; 

    public void Clear() 
    { 
     fixed(byte* ptr=data) 
     { 
      // Fill values with 0 
      for(int i=0; i<Size; i++) 
      { 
       ptr[i]=0; 
      } 
     } 
    } 

    public void Store(byte[] array, int index) 
    { 
     fixed(byte* ptr=data) 
     { 
      // find max elements remaining 
      int N=Math.Min(index + array.Length, Size) - index; 
      // Fill values from input bytes 
      for(int i=0; i<N; i++) 
      { 
       ptr[index+i]=array[i]; 
      } 
     } 
    } 

    public byte[] ToArray() 
    { 
     byte[] array=new byte[Size]; 
     fixed(byte* ptr=data) 
     { 
      // Extract all data 
      for(int i=0; i<Size; i++) 
      { 
       array[i]=ptr[i]; 
      } 
     } 
     return array; 
    } 
} 

unsafe class Program 
{ 
    static void Main(string[] args) 
    { 
     Buffer buffer=new Buffer(); 
     // buffer contains 100 bytes 
     int size=sizeof(Buffer); 
     // size = 100 
     buffer.Clear(); 
     // data = { 0, 0, 0, ... } 
     buffer.Store(new byte[] { 128, 207, 16, 34 }, 0); 

     byte[] data=buffer.ToArray(); 
     // { 128, 207, 16, 34, 0, 0, ... } 
    } 
} 

（PS需要用編譯允許不安全代碼）

Answer 4

使用類而不是結構。

Answer 5

如何：

struct Check 
{ 
    private int[] _x ; 
    public int[] X { get { return _x ?? new int[3]{0,0,0,} ; } } 
} 

，直到它被引用這會延遲內部數組的實例。假設陣列參考在實例的整個生命週期內保持不變，所以您確實不需要set訪問器。這裏唯一的缺點是由於第一次引用屬性X時隱含競爭條件，所以這不是線程安全的。然而，由於你的結構假定存在於堆棧中，所以這可能不是一個大問題。

Answer 6

這可能會有很大的幫助。我創建了結構MyX， Struct包含方法ToByte和Struct 因此，如果您有字節數組，您可以用字節 填充您的結構數組但是請確保您的字節數組對齊正確。 希望這有助於。

public struct MyX 
    { 
     public int IntValue; 
     [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3, ArraySubType = UnmanagedType.U1)] 
     public byte[] Array; 

     MyX(int i, int b) 
     { 
      IntValue = b; 
      Array = new byte[3]; 
     } 

     public MyX ToStruct(byte []ar) 
     { 

      byte[] data = ar;//= { 1, 0, 0, 0, 9, 8, 7 }; // IntValue = 1, Array = {9,8,7} 
      IntPtr ptPoit = Marshal.AllocHGlobal(data.Length); 
      Marshal.Copy(data, 0, ptPoit, data.Length); 

      MyX x = (MyX)Marshal.PtrToStructure(ptPoit, typeof(MyX)); 
      Marshal.FreeHGlobal(ptPoit); 

      return x; 
     } 
     public byte[] ToBytes() 
     { 
      Byte[] bytes = new Byte[Marshal.SizeOf(typeof(MyX))]; 
      GCHandle pinStructure = GCHandle.Alloc(this, GCHandleType.Pinned); 
      try 
      { 
       Marshal.Copy(pinStructure.AddrOfPinnedObject(), bytes, 0, bytes.Length); 
       return bytes; 
      } 
      finally 
      { 
       pinStructure.Free(); 
      } 
     } 
    } 

    void function() 
    { 
     byte[] data = { 1, 0, 0, 0, 9, 8, 7 }; // IntValue = 1, Array = {9,8,7} 
     IntPtr ptPoit = Marshal.AllocHGlobal(data.Length); 
     Marshal.Copy(data, 0, ptPoit, data.Length); 

     var x = (MyX)Marshal.PtrToStructure(ptPoit, typeof(MyX)); 
     Marshal.FreeHGlobal(ptPoit); 

     var MYstruc = x.ToStruct(data); 


     Console.WriteLine("x.IntValue = {0}", x.IntValue); 
     Console.WriteLine("x.Array = ({0}, {1}, {2})", x.Array[0], x.Array[1], x.Array[2]); 
    }