<p>I am wrapping a native C++ class, which has the following methods:</p>

<pre><code>class Native
{
    public:
    class Local
    {
        std::string m_Str;
        int m_Int;
    };

    typedef std::vector&lt;Local&gt; LocalVec;
    typedef LocalVec::iterator LocalIter;

    LocalIter BeginLocals();
    LocalIter EndLocals();

    private:
        LocalVec m_Locals;
};
</code></pre>

<p>1) What is the ".NET way" of representing this same kind of interface? A single method returning an array&lt;>? Does the array&lt;> generic have iterators, so that I could implement BeginLocals() and EndLocals()? </p>

<p>2) Should Local be declared as a <strong>value struct</strong> in the .NET wrapper?</p>

<p>I'd really like to represent the wrapped class with a .NET flavor, but I'm very new to the managed world - and this type of information is frustrating to google for...</p>

Iterators aren't exactly translatable to "the .net way", but they are roughly replaced by IEnumerable < T > and IEnumerator < T >.
Rather than
```
```
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++;
  }
```
```
you would see (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;
}
```
```
Or more explicitly (without hiding the IEnumerator behind the foreach syntax sugar):
```
```
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;
}
```
```
As you can see, foreach just hides the .net enumerator for you.
So really, the ".net way" would be to simply allow people to create List< Local > items for themselves.   If you do want to control iteration or make the collection a bit more custom, have your collection implement the IEnumerable< T > and/or ICollection< T > interfaces as well.
A near direct translation to c# would be pretty much what you assumed:
```
```
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;}
  }
}
```
```
Then a user would be able to
```
```
foreach( Local item in someNative.Locals)  
{
 ... 
}
```
```