Konvertieren von std :: vector <> :: Iterator auf .NET-Schnittstelle in C ++ / CLI

Question

Ich bin Einwickeln eine native C ++ Klasse, die die folgenden Methoden hat:

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) Was ist die „.NET Art und Weise“ zu repräsentieren diese gleiche Art von Schnittstelle? Eine einzige Methode ein Array Rückkehr <>? Ist das Array <> generic Iteratoren haben, so dass ich BeginLocals implementieren könnte () und EndLocals ()?

2) Sollten Lokale als deklariert wird Wert struct in dem .NET-Wrapper?

Ich möchte wirklich die verpackte Klasse mit einem .NET-Geschmack repräsentieren, aber ich bin sehr neu in der verwalteten Welt - und diese Art von Informationen ist frustrierend für ...

to google

Answer 1

Iteratoren sind nicht genau übersetzbar „der .net Weg“, aber sie sind grob durch IEnumerable ersetzt und IEnumerator .

Anstatt

  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++;
  }

Sie sehen würden (in 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;
}

oder mehr explizit (ohne den IEnumerator hinter dem foreach-Syntax Zucker versteckt):

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;
}

Wie Sie sehen können, foreach nur versteckt die .net enumerator für Sie.

Also wirklich, der „.net Weg“ wäre, einfach Menschen erlaubt List Produkte für sich selbst zu schaffen. Wenn Sie nicht möchten Iteration steuern oder die Sammlung ein bisschen mehr benutzerdefinierte machen, haben Ihre Sammlung die IEnumerable implementieren und / oder ICollection Schnittstellen als auch.

Ein in der Nähe von direkter Übersetzung c # wäre ziemlich viel, was Sie angenommen:

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;}
  }
}

Dann ein Benutzer der Lage wäre,

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

Answer 2

@Phillip - Vielen Dank, Ihre Antwort hat mich wirklich in die richtige Richtung gestartet.

Nachdem Sie den Code zu sehen, und dabei ein wenig mehr Lesung in Nish Buch C ++ / CLI in Aktion , ich denke, eine indizierte Eigenschaft verwenden, die auf dem verwalteten Heap ein const Tracking Handle auf eine lokale Instanz zurückgibt ist wahrscheinlich der beste Ansatz. Ich landete etwas Umsetzung ähnlich der folgenden:

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;
};