C#

OriginalGriff wrote:

as a bonus you gain equality, greater than, and less than operators for the class directly

public static bool operator <(Foo left, Foo right) => left is null || left.CompareTo(right) < 0;
public static bool operator <=(Foo left, Foo right) => left is null || left.CompareTo(right) <= 0;
public static bool operator >=(Foo left, Foo right) => left != null && left.CompareTo(right) >= 0;
public static bool operator >(Foo left, Foo right) => left != null && left.CompareTo(right) > 0;

[Flags]
enum YourRevisedPriority
{
   SuperUser     = &x0000, 
   NormalUser    = &x0100, 
   Beginner      = &x0200,

   Internal      = &x0000,
   External      = &x0010,

   Valid         = &x0000,
   ValidInFuture = &x0001,
   Expire        = &x0002
}

TransformedProfile = profileList.Select(x => new TransformedProfile
    {
    ProfileType = GetProfileType(x.PropertyA),
    // ProfileSubType = GetProfileSubType(x.PropertyB),
    ProfileValidity = GetValidity(x.StartDate, x.ExpiryDate),
    NewPriority = 
      (ProfileType == SourceEnum.SuperUser ? YourRevisedPriority.SuperUser : (ProfileType == SourceEnum.NormalUser ? YourRevisedPriority.NormalUser : YourRevisedPriority.Beginner)) +
      (GetProfileSubType(x.PropertyB) == SourceEnum.Internal ? YourRevisedPriority.Internal : YourRevisedPriority.External) +
      (ProfileValidity == SourceEnum.Valid ? YourRevisedPriority.Valid : (ProfileValidity == SourceEnum.ValidInFuture ? YourRevisedPriority.ValidInFuture : YourRevisedPriority.Expire))
    })
    .OrderBy(y => y.NewPriority)
    .FirstOrDefault();

        private Dictionary<Keys, Func<int>> keyFunctions = new Dictionary<Keys, Func<int>>();
        private int A()
            {
            Console.WriteLine("A");
            return 1;
            }
        private int B()
            {
            Console.WriteLine("B");
            return 2;
            }
        private int C()
            {
            Console.WriteLine("C");
            return 3;
            }
...
            keyFunctions.Add(Keys.A, A);
            keyFunctions.Add(Keys.B, B);
            keyFunctions.Add(Keys.C, C);
...

Console.WriteLine(keyFunctions[Keys.C]());
Console.WriteLine(keyFunctions[Keys.B]());
Console.WriteLine(keyFunctions[Keys.A]());

keyFunctions.Add(Keys.A, () => A());
keyFunctions.Add(Keys.B, () => B());
keyFunctions.Add(Keys.C, () => C());

Wiep Corbier wrote:

Will this ever happen and if not, why not?

Quote:

Computers aren't magic. They can't "guess" which class you meant to use.

Wiep Corbier wrote:

People will ask, which Richard?

Wiep Corbier wrote:

C# (8?) now has the ability to work around null values in classes.
Who asked for that? I didn't.
Who cares? No one.

Richard Deeming wrote:

There has to be some way to disambiguate the two people. Usually you would use the surname.