Conversion de std :: vector < > :: iterator en interface .NET en C ++ / CLI

Question

J'emballe une classe C ++ native, qui utilise les méthodes suivantes:

class Native
{
    public:
    class Local
    {
        std::string m_Str;
        int m_Int;
    };

    typedef std::vector<Local> LocalVec;
    typedef LocalVec::iterator LocalIter;

    LocalIter BeginLocals();
    LocalIter EndLocals();

    private:
        LocalVec m_Locals;
};

1) Quelle est la méthode ".NET"? de représenter ce même type d'interface? Une seule méthode renvoyant un tableau < > ;? Le tableau < > generic a des itérateurs, afin que je puisse implémenter BeginLocals () et EndLocals ()?

2) Est-ce que Local doit être déclaré en tant que valeur struct dans le wrapper .NET?

J'aimerais vraiment représenter la classe enveloppée avec une saveur .NET, mais je suis très novice dans le monde géré - et ce type d'informations est frustrant pour Google ...

Answer 1

Les itérateurs ne sont pas exactement traduisibles en "façon .net", mais ils sont à peu près remplacés par IEnumerable < T > et IEnumerator < T > ;.

Plutôt que

  vector<int> a_vector;
  vector<int>::iterator a_iterator;
  for(int i= 0; i < 100; i++)
  {
    a_vector.push_back(i);
  }

  int total = 0;
  a_iterator = a_vector.begin();
  while( a_iterator != a_vector.end() ) {
    total += *a_iterator;
    a_iterator++;
  }

vous verriez (en c #)

List<int> a_list = new List<int>();
for(int i=0; i < 100; i++)
{
  a_list.Add(i);
}
int total = 0;
foreach( int item in a_list)
{
  total += item;
}

Ou plus explicitement (sans cacher l'IEnumerator derrière le sucre de la syntaxe foreach):

List<int> a_list = new List<int>();
for (int i = 0; i < 100; i++)
{
    a_list.Add(i);
}
int total = 0;
IEnumerator<int> a_enumerator = a_list.GetEnumerator();
while (a_enumerator.MoveNext())
{
    total += a_enumerator.Current;
}

Comme vous pouvez le constater, foreach ne fait que masquer l’énumérateur .net.

Donc vraiment, la "manière .net" serait simplement permettre aux gens de créer List < Local > articles pour eux-mêmes. Si vous souhaitez contrôler les itérations ou personnaliser davantage la collection, demandez à votre collection d'implémenter IEnumerable < T > et / ou ICollection < T > interfaces également.

Une traduction presque directe en c # serait à peu près ce que vous supposiez:

public class Native
{
  public class Local
  { 
     public string m_str;
     public int m_int;
  }

  private List<Local> m_Locals = new List<Local>();

  public List<Local> Locals
  {
    get{ return m_Locals;}
  }
}

Ensuite, un utilisateur pourrait

foreach( Local item in someNative.Locals)  
{
 ... 
}

Answer 2

@Phillip - Merci, votre réponse m'a vraiment permis de démarrer dans la bonne direction.

Après avoir vu votre code et lu un peu plus dans le livre C ++ / CLI en action de Nish, je pense utiliser une propriété indexée qui renvoie un descripteur de suivi const à une instance locale du segment de mémoire géré. est probablement la meilleure approche. J'ai fini par mettre en œuvre quelque chose de similaire au suivant:

public ref class Managed
{
    public:
    ref class Local
    {
        String^ m_Str;
        int m_Int;
    };

    property const Local^ Locals[int]
    {
        const Local^ get(int Index)
        {
            // error checking here...
            return m_Locals[Index];
        }
    };

    private:
        List<Local^> m_Locals;
};