C#

enum zeConstants: int
{
    bla1,
    CListCtrl,
    bacon,
    StarWars = 7
}

static void Main()
{
    foreach (zeConstants flag in Enum.GetValues(typeof(zeConstants)))
    {
        Console.WriteLine("{0} = {1}", flag, (int)flag);
    }

    Console.ReadLine();
}

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

public enum UniqueValue
     {
     Fred,
     Barney,
     Dino,
     BamBam,
     Pebbles,
     MrSlate,
     Arnold
     }

C-P-User-3 wrote:

Please, I gotta be wrong on that. Correct me and show me where, and what this is doing, and where the syntax is defined..

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:

Got confused when the C# IDE put "UniqueValue" in bright pink on my screen.

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

public enum Zyxwvut
  {
  OneValue,
  AnotherValue,
  WhateverValue,
  AndSoOn
  }

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