C#

From the MSDN page:

Usually it is best to define an enum directly within a namespace so that all classes in the namespace can access it with equal convenience. However, an enum can also be nested within a class or struct.

C-P-User-3 wrote:

I could just use the name "Fred"

C-P-User-3 wrote:

I can use the names in the enum list as they are ? Without the UniqueValue.Fred nomenclature ?

Bastard Programmer from Hell
If you can't read my code, try converting it here[^]
They hate us for our freedom![^]

C-P-User-3 wrote:

Looked it up on MSDN and DUH !!! They don't have it referenced !

Richard MacCutchan wrote:

Perhaps it would be worth getting hold of a good reference on C# (.NET Book Zero[^] is a reasonable start), rather than trying to learn from CodeProject questions.

From Petzold's Book:

The latest version of Windows—Microsoft Windows Vista—includes the .NET Framework 3.0

C-P-User-3 wrote:

i.e., I'm studying trailing edge technology which nobody will want next year.

RickSharp wrote:

Doesn DataGridView require a form to view the results or something?

Bastard Programmer from Hell
If you can't read my code, try converting it here[^]
They hate us for our freedom![^]

RickSharp wrote:

By entry point do you mean is it just a win form, exe or class library? If so I have added a form project and console application project to my solution. So I have a class library that contains that code. I added a reference to that class library in the new forms and console projects that I created. I tried following this tutorial with no success.

Bastard Programmer from Hell
If you can't read my code, try converting it here[^]
They hate us for our freedom![^]

static void Sort<T>(IList<T> sortKey, params IList<T>[] otherLists)
{
   // TODO: Validate the arguments:
   // - None of the lists are null;
   // - All of the lists have the same length;

   Action<IList<T>, IDictionary<int, int>> sortList = (list, keys) =>
   {
      var values = list
         .Select((value, i) => new { key = keys[i], value })
         .OrderBy(p => p.key).Select(p => p.value);

      int index = 0;
      foreach (T value in values)
      {
         list[index++] = value;
      }
   };

   // Key is the index in the input list;
   // Value is the index in the output list.
   var indices = Enumerable.Range(0, sortKey.Count)
      .OrderBy(i => sortKey[i])
      .Select((key, value) => new { key, value })
      .ToDictionary(p => p.key, p => p.value);

   sortList(sortKey, indices);
   foreach (var list in otherLists)
   {
      sortList(list, indices);
   }
}

public sealed class ListHelper<T> : IEnumerable<IList<T>>
{
   private int _sortIndex = -1;
   private IDictionary<int, int> _indexMap; // Source to target
   private IDictionary<int, int> _reverseIndexMap; // Target to source
   private readonly List<MappedList> _lists = new List<MappedList>();
   
   public int SortIndex
   {
      get
      {
         return _sortIndex;
      }
      set
      {
         if (value < -1 || value >= _lists.Count) 
         {
            throw new ArgumentOutOfRangeException();
         }
         
         if (-1 == value)
         {
            if (0 != _lists.Count)
            {
               int size = _lists[0].Count;
               _indexMap = Enumerable.Range(0, size).ToDictionary(i => i);
               _reverseIndexMap = _indexMap;
            }
         }
         else
         {
            IList<T> sortKey = _lists[value].InnerList;
            
            _indexMap = Enumerable.Range(0, sortKey.Count)
               .OrderBy(i => sortKey[i])
               .Select((key, v) => new { key, value = v })
               .ToDictionary(p => p.key, p => p.value);
            
            _reverseIndexMap = _indexMap.ToDictionary(p => p.Value, p => p.Key);
         }
      }
   }
   
   public int Count
   {
      get { return _lists.Count; }
   }
   
   public IList<T> this[int index]
   {
      get { return _lists[index]; }
   }
   
   public void Add(IList<T> listToAdd)
   {
      if (_indexMap == null)
      {
         _indexMap = Enumerable.Range(0, listToAdd.Count).ToDictionary(i => i);
         _reverseIndexMap = _indexMap;
      }
      else if (_indexMap.Count != listToAdd.Count)
      {
         throw new ArgumentException("Invalid list size!", "list");
      }

      _lists.Add(new MappedList(listToAdd, this));
   }
   
   public IEnumerator<IList<T>> GetEnumerator()
   {
      return _lists.GetEnumerator();
   }
   
   IEnumerator IEnumerable.GetEnumerator()
   {
      return GetEnumerator();
   }
   
   private sealed class MappedList : IList<T>
   {
      private readonly IList<T> _list;
      private readonly ListHelper<T> _parent;
      
      public MappedList(IList<T> list, ListHelper<T> parent)
      {
         _list = list;
         _parent = parent;;
      }
      
      public IList<T> InnerList
      {
         get { return _list; }
      }
      
      public T this[int index] 
      { 
         get
         {
            int realIndex = _parent._reverseIndexMap[index];
            return _list[realIndex];
         }
         set
         {
            int realIndex = _parent._reverseIndexMap[index];
            _list[realIndex] = value;
         }
      }
      
      public int Count
      {
         get { return _list.Count; }
      }
      
      public bool IsReadOnly
      {
         get { return _list.IsReadOnly; }
      }
      
      public IEnumerator<T> GetEnumerator()
      {
         for (int i = 0; i < _list.Count; i++)
         {
            int index = _parent._reverseIndexMap[i];
            yield return _list[index];
         }
      }
      
      IEnumerator IEnumerable.GetEnumerator()
      {
         return GetEnumerator();
      }
      
      public int IndexOf(T item)
      {
         int result = _list.IndexOf(item);
         return -1 == result ? -1 : _parent._indexMap[result];
      }
      
      public void CopyTo(T[] array, int arrayIndex)
      {
         foreach (T item in this)
         {
            array[arrayIndex++] = item;
         }
      }
      
      public bool Contains(T item)
      {
         return _list.Contains(item);
      }
      
      public void Add(T item)
      {
         throw new NotSupportedException();
      }
      
      public void Insert(int index, T item)
      {
         throw new NotSupportedException();
      }
      
      public bool Remove(T item)
      {
         throw new NotSupportedException();
      }
      
      public void RemoveAt(int index)
      {
         throw new NotSupportedException();
      }
      
      public void Clear()
      {
         throw new NotSupportedException();
      }
   }
}

...

var helper = new ListHelper<int>
{
   new[] { 04, 09, 03, 06 },
   new[] { 20, 50, 40, 30 },
   new[] { 15, 45, 85, 65 },
   new[] { 89, 39, 19, 99 },
};

helper.SortIndex = 0;

foreach (IList<T> list in helper)
{
   // Either foreach or for will work here:
   for (int index = 0; index < list.Count; index++)
   {
      // Each list will be sorted based on the order of the first list:
      Console.WriteLine(list[index]);
   }
}

{
  { 09 , 20 , 15 , 89 }
  { 06 , 50 , 45 , 39 }
  { 04 , 40 , 85 , 19 }
  { 03 , 30 , 65 , 99 }
}

{
  { 03 , 30 , 65 , 99 }
  { 04 , 40 , 85 , 19 }
  { 06 , 50 , 45 , 39 }
  { 09 , 20 , 15 , 89 }
} 

class OrderHelper<T> : IComparable<OrderHelper<T>> {
 public T Item {get; private set;}
 public int Order {get; private set;}

 public OrderHelper(T item, int order) { this.Item = item; this.Order = order; }

 public int CompareTo(OrderHelper<T> other) {
  return Comparer<T>.Default.Compare(Item, other.Item);
 }
}

int index = 0;
List<OrderHelper<int>> orderedList = listOne.Select(i => new OrderHelper(i, index++)).ToList();

orderedList.Sort();
List<int> indices = orderedList.Select(oi => oi.Order).ToList();

public static List<T> OrderBy(List<T> list, List<int> indices){
 List<T> r = new List<T>(indices.Count);
 for(int i = 0; i < r.Count; i++){
  r[i] = list[indices[i]];
 }  
 return r;
}

// ...
listTwo = OrderBy(listTwo, indicies);
listThree = OrderBy(listThree, indicies);
// etc

public class Staff
{
    private string staffName;
    public string StaffName
    {
        get
        {
            return staffName;
        }
        set
        {
            staffName = value;
        }
    }
}

public class Professor : Staff
{
    // things unique to Professors
}

public class Lecturer : Staff
{
    // things unique to Lecturers
}

Matt U. wrote:

In Richard's response, he changed the access modifier for "string staffName" to "private" rather than "protected".

Matt U. wrote:

What if the new class needed its own implementation of 'StaffName'?