È una cattiva pratica mettere un sacco di codice nella funzione get di una proprietà che avvolge le cose di PInvoke?

Question

Un titolo confuso che conosco. Lasciami spiegare.

Devo eseguire il marshalling di una matrice di strutture, che quindi vengono convertite in una matrice di classi (compatibilità legacy). Ad esempio

public class InnerClass {}

public class OuterClass { private InnerClass[] innerClasses; }


public struct InnerStruct {
   // Data
}

private static buildInnerClass( InnerStruct i );

public struct OuterStruct {
   private int _numInnerStructs;
   private IntPtr _innerStructs;
   // Other members

   public InnerClass[] InnerClasses {
      get {
             InnerClass[] ret = new InnerClass[_numInnerStructs];

             var structSize = Marshal.SizeOf(typeof(InnerStruct));
             var ptr = _innerStructs;

             for (int i = 0; i < _numInnerStructs; i++)
             {
                InnerStruct innerStruct = (InnerStruct)Marshal.PtrToStructure(
                                          ptr, typeof(InnerStruct));
                ret[i] = buildInnerClass(innerStruct);
                ptr = (IntPtr)((int)ptr + structSize);
             }
             return ret;
      }
   }

}

Answer 1

Visto nel vuoto, non c'è nulla di intrinsecamente sbagliato in questa pratica. Tuttavia, dovresti stare attento in questo ...

1. I getter di proprietà dovrebbero - con poche (se presenti) eccezioni - non essere "costosi". (vale a dire, non dovrebbe consumare molti cicli o risorse della CPU per eseguire)
2. I getter di proprietà non devono MAI causare effetti collaterali. Ad esempio, se il tuo codice PInvoke ottiene un nuovo handle di qualche tipo, allora dovrebbe essere una funzione, non un getter.

In generale, tieni presente che le proprietà dovrebbero essere scritte in modo tale che il consumatore non dovrebbe avere molti, se del caso, motivi per memorizzare nella cache il valore anziché chiamare nuovamente la proprietà. Se uno sviluppatore responsabile può seguire questa pratica con la tua proprietà, allora sei sulla strada giusta.

Answer 2

Il getter di una proprietà dovrebbe essere il minimo possibile. Nel tuo caso, probabilmente è meglio usare un metodo regolare. Soprattutto perché restituire un array da una proprietà è anche una cattiva idea.

Answer 3

Non è peggio mettere quel codice in una struttura PInvoke di quanto non lo sia metterlo in una normale struttura. Ai fini di PInvoke, vengono considerati solo i campi di una struttura e quindi il tuo codice proprietà non entrerà in gioco. Sarà rilevante solo quando il tuo codice accede a quella particolare proprietà.