C# résumé struct

À la lumière de vos récents edit:

La raison que j'ai besoin de types de valeur est ainsi que je peux faire un tableau d'entre eux, et de passer à OpenGL comme un vertex buffer. Pour cela, les données doivent être directement contenus dans ce tableau.

Il semble que la réel solution pour vous est d'encapsulation. Si la mise en page de votre struct est dicté par une API tierce (de sorte que vous pouvez interagir avec du code non managé), alors vous devriez vraiment envisager d'emballage l'API types dans les classes appropriées plutôt que d'essayer d'interagir avec eux directement dans le code.

Pour l'un, vous dites ceci:

J'ai besoin d'elle comme d'une struct, car il doit être d'un type valeur. Et j'ai besoin d'héritage, car j'ai besoin d'un générique de tableau et les méthodes que je vous garantissons sont là.

Ce n'est pas la façon dont vous vous attendez. Comme d'autres l'ont souligné, la seule manière de définir un ensemble commun d'une fonctionnalité qui peut s'appliquer à des structures est par l'intermédiaire d'interfaces (par exemple, les types primitifs .NET mettre en œuvre IComparable). Malheureusement, si vous déclarez un tableau de type IYourInterface, toutes les valeurs obtiendrez en boîte (interface références sont des types référence, même si la valeur sous-jacente elles sont pointant vers sont des types de valeur).

Par exemple, disons que vous déclarez un IVertex interface:

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

Et vous avez un ou plusieurs types de valeur que sa mise en oeuvre:

struct ColorVertex : IVertex
{
   Vector3 Position;
   Vector4 Color;

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

Chaque fois que vous faites cela:

ColorVertex myVertex = new ColorVertex();

IVertex foo = myVertex;

La deuxième ligne de la valeur de myVertex et de stocker une référence à cette boîte de valeur dans foo. Comme les tableaux sont juste une série de variables, les mêmes règles s'appliquent:

IVertex[] foos = { myVertex };

Toutes les valeurs de foos sera en boîte, et de leurs références stockées. C'est différent que si vous avez fait:

ColorVertex[] colors = { myVertex };

Où aucun de boxe est nécessaire.

Cela a des conséquences directement liées à ce que vous recherchez, comme la boxe, les valeurs maintenant signifie que vous n'avez plus d'un bloc contigu de valeurs (le bien, vous le faites, mais le contiguë bloc de références; les valeurs elles-mêmes sont ailleurs).

Encapsulation

Compte tenu du fait que vous

1. Ont une API tierce avec la définition d'un type que vous avez besoin d'interagir avec
2. L'exigence à l'appui de différents cas d'utilisation dans votre code et que vous souhaitez utiliser orientée objet patrons de conception à faire

Vous devriez vraiment envisager d'enveloppement de l'API OpenGL. Par exemple, disons que vous disposez des éléments suivants:

//OpenGL type
struct Vertex
{
    int SizeInBytes;
}

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

Ce qui est probablement une meilleure option serait de définir votre propre interface, puis se cacher 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);
    }
}

(C'est évidemment un exemple artificiel, mais il doit démontrer ce que je suis en train de faire en termes d'introduction d'une couche d'abstraction entre votre code et les autres API)

OriginalL'auteur Adam Robinson

Vous ne pouvez pas, dans le fond. Vous ne pouvez pas tirer à partir d'une struct. Pourquoi pensez-vous que vous voulez une structure plutôt qu'une classe? Vous dites "il a à un type de valeur" - pourquoi? De même pensez-vous de l'héritage est la seule option à la place de (disons) de la composition? Par exemple, vous pourriez utiliser:

public struct Vertex
{
    //...
}

public struct Color
{
    //...
}

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

    //...
}

Vous êtes tout simplement pas va être en mesure d'obtenir un "abstract struct" ou quelque chose de semblable à travailler, alors je vous suggère de vous expliquer le raisons derrière votre unsatisfiable exigences, au lieu de juste dire comme des exigences qui ne peuvent pas être évités.

OriginalL'auteur Jon Skeet

Vous pouvez utiliser les interfaces

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

struct ColorVertex : IVertex
{
   Vector3 Position;
   Vector4 Color;

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

OriginalL'auteur ja72

Vous pouvez créer une interface IVertex et puis l'ajouter à Vos structures.

OriginalL'auteur Damian Leszczyński - Vash

Classes peuvent être "types de valeur" (dans le sens utilisé dans le Domain Driven Design). Tout ce que vous avez à faire c'est immuable, faire les constructeurs inaccessibles au grand public (Protégés ou à l'interne), et de créer statique usine méthodes pour créer des instances de leur contrôle et de leur instanciation, et n'ont aucun setters sur vos biens...

REMARQUE: L'expression Type de Valeur dans ce contect n'a rien à voir avec le type de Valeur vs Type de Référence. Il a à voir avec Type de Valeur vs Type d'Entité employé dans le Domaine Drtiven Design ou un Domaine de Modélisation...

OriginalL'auteur Charles Bretana