C# struct abstract

Im Licht Ihrer kürzlichen edit:

Den Grund brauche ich Wert-Typen ist so, dass ich ein array von Ihnen, und übergeben es an OpenGL als vertex-buffer. Für die Daten, die benötigt werden, direkt enthalten, in das array.

Scheint es, wie die real Lösung für Sie ist die Kapselung. Wenn Sie das layout Ihres struct ist diktiert von einem third-party-API (so dass Sie interagieren können mit unmanaged code), dann sollte man sich wirklich überlegen, das einwickeln der API-Typen in den entsprechenden Klassen, anstatt zu versuchen, mit Ihnen zu interagieren, direkt in den code.

Für ein, Sie sagen:

Ich brauche es als eine Struktur, weil es einen Wert geben. Und ich brauche Vererbung, denn ich brauche einen generischen array und Methoden, die ich kann garantieren, gibt es.

Dies ist nicht das entpuppen, was Sie erwarten. Wie andere haben darauf hingewiesen, daß die einzige Möglichkeit zur Festlegung einer Reihe von gemeinsamen Funktionen anwenden können, um Strukturen ist durch Schnittstellen (zum Beispiel, die primitiven Datentypen in .NET implementieren IComparable). Leider, wenn Sie deklarieren ein array vom Typ IYourInterface alle Werte erhalten boxed (interface-Referenzvariablen Referenztypen, selbst wenn der zugrunde liegende Wert Sie sind, zeigen auf, sind Wert-Typen).

Zum Beispiel, sagen wir, Sie erklären eine IVertex Schnittstelle:

public interface IVertex
{
    int SizeInBytes { get; }
    void SetPointers();
}

Haben, und Sie haben ein oder mehrere Wert-Typen, die es umzusetzen:

struct ColorVertex : IVertex
{
   Vector3 Position;
   Vector4 Color;

   override int SizeInBytes //static
   {
      get { return (3 + 4) * 4; }
   }
   override void SetVertexPointers() //static
   {
       ...
   }
}

Wann immer Sie dies tun:

ColorVertex myVertex = new ColorVertex();

IVertex foo = myVertex;

Die zweite Zeile Feld den Wert myVertex und speichern Sie einen Verweis auf die boxed-Wert in foo. Da arrays sind nur eine Reihe von Variablen gelten die gleichen Regeln:

IVertex[] foos = { myVertex };

Alle Werte in foos wird boxed und Referenzen gespeichert. Dies ist anders, als wenn du es getan hast:

ColorVertex[] colors = { myVertex };

Wo keine Boxen notwendig ist.

Dies hat Konsequenzen, die in direktem Zusammenhang zu dem, was Sie suchen sind, als Boxen die Werte nun bedeutet, dass Sie nicht mehr ein zusammenhängender block von Werten (gut, Sie tun, aber der zusammenhängenden block ist nur Verweise; die Werte selbst liegen anderswo).

Kapselung

Angesichts der Tatsache, dass Sie

1. Ein third-party-API mit einem definierten Typ, die Sie benötigen, um die Interaktion mit
2. Die Voraussetzung für die Unterstützung der verschiedenen Anwendungsfälle in Ihrem code verwenden möchten, Objekt-orientierte design-Pattern zu tun, so

Sollten Sie sich wirklich überlegen, das einwickeln der OpenGL-API. Zum Beispiel, sagen wir, dass Sie Folgendes haben:

//OpenGL type
struct Vertex
{
    int SizeInBytes;
}

public static extern void OpenGLFunction(Vertex[] vertices);

Was ist wahrscheinlich eine bessere option wäre, um zu definieren, Ihre eigene Schnittstelle zu, dann verstecken Sie die OpenGL-API:

public abstract class VertexBase
{
    internal Vertex ToVertex()
    {
        //your logic here
    }
}

public static class OpenGL
{
    public static void WrappedFunction(VertexBase[] vertices)
    {
        Vertex[] outVertices = new Vertex[vertices.Length];

        for(int i = 0; i < vertices.Length; i++)
        {
            outVertices[i] = vertices[i].ToVertex();
        }

        OpenGLFunction(outVertices);
    }
}

(Das ist natürlich ein erfundenes Beispiel, aber es sollte zeigen, was ich versuche zu vermitteln in Bezug auf die Einführung einer Abstraktionsschicht zwischen Ihrem code und die andere API)

Kann man nicht, im Grunde. Können Sie nicht ableiten, aus einer struct. Warum denken Sie, dass Sie möchten, dass ein struct statt der Klasse? Sie sagen: "es muss einen Wert geben" - warum? Ebenfalls denken Sie, Vererbung ist die einzige option, die anstelle von (sagen wir) Zusammensetzung? Zum Beispiel könnten Sie verwenden:

public struct Vertex
{
    //...
}

public struct Color
{
    //...
}

public struct ColorVertex
{
    private readonly Color color;
    private readonly Vertex vertex;

    //...
}

Du bist einfach nicht in der Lage sein, um eine "abstrakte Struktur" oder etwas ähnlichem zu arbeiten, so dass ich schlage vor, Sie erklären die Gründen hinter Ihre Anforderungen unerfüllbar, anstatt nur unter Angabe Sie als Anforderungen, die nicht vermieden werden können.

Können Sie Schnittstellen

interface IVertex 
{
    int SizeInBytes();
    void SetPointers();
}

struct ColorVertex : IVertex
{
   Vector3 Position;
   Vector4 Color;

   int SizeInBytes
   {
      get { return (3 + 4) * 4; }
   }
   void SetVertexPointers()
   {
       ...
   }
}

Können Sie erstellen, die Schnittstelle IVertex und dann hinzufügen, um Ihre Strukturen.

Klassen "Wert-Typen" als gut (im Sinne von Domain-Driven Design). Alles, was Sie tun müssen, ist es unveränderlich, machen die Konstruktoren unzugänglich öffentlich (Protected oder internal), und erstellen Sie statische factory-Methoden, um Instanzen zu erstellen und Sie zu kontrollieren, Ihre Instanziierung und haben keine Set-Methoden auf Ihre Eigenschaften...

HINWEIS: Der Satz Wert Typ in diesem contect hat nichts zu tun mit dem Wert Typ vs Typ der Referenz. Es hat zu tun mit Wert Typ vs Entity-Typ wie in der Domäne Drtiven Design oder Domain Modeling...