¿Puedo crear operadores ternarios en C#?

Question

Quiero crear un operador ternario para un < b < c que es un < b & < c. o cualquier otra opción que se te ocurra que es < b> c y así sucesivamente ... Soy fanático de mi propia versión corta y quería crear eso desde que aprendí programación en la escuela secundaria.

¿Cómo?

Answer 1

¿Ha intentado buscar operadores ternarios en google para ver si algo ya existe?

Answer 2

No puede hacer eso. Solo puedes implementar operadores existentes, y no hay ternario. <. <. operador en C#.

Además, dicho operador sería ambiguo con los operadores de comparación existentes. Por ejemplo, ¿la expresión a == b == c == d significa ((a == b) == c) == d o (a == b == c) == d?

Answer 3

No. No en C#. La extensión de idioma de esta manera no está disponible en ninguna versión actual de C#, pero Luca Bolognese apuntó a usar el compilador como un servicio y algunas funcionalidades que podrían permitir extender el idioma de esta manera: http://microsoftpdc.com/Sessions/FT11.

Answer 4

Si desea hacer eso para los tipos de datos primitivos, no tiene suerte. C# no admite agregar operadores a esos.

En sus propios tipos de datos es posible devolver un tipo de datos especial que almacena el resultado intermedio y el resultado de la comparación. Sin embargo, le sugiero que simplemente se adhiera al lenguaje C# - si realmente desea el estilo de operador a < b < c, cambie a Python.

Answer 5

Lo sentimos, no puede crear sus propios operadores en C#.

Usted podría utilizar los métodos de extensión para permitir una sintaxis fluida como

bool f = b.IsBetween(a, c); 

O, si estaban siendo muy inteligente, se podría hacer:

bool f = a.IsLessThan(b).IsLessThan(c); 

hacerlo es difícil, pero posible. (Sugerencia: defina un objeto personalizado que devuelva IsLessThan que rastree sus límites y comprenda cómo se combina con otras instancias del objeto. Básicamente, así es como funciona LINQ-to-SQL con respecto a la combinación de Where, Select, etc.).

Pero no puede definir sus propias sintaxis de operador en C#.

Si le interesan los idiomas en los que puede definir sus propios operadores, puede considerar buscar F #.

Answer 6

No creo que los enemigos;)

Usted puede hacer esto en C#. Aquí hay una implementación de ejemplo — He basado el encadenamiento de la forma en que Icon hace el suyo ... si una comparación tiene éxito, el resultado es el del parámetro correcto, de lo contrario se devuelve un resultado especial "fallido".

La única sintaxis adicional que necesita utilizar es la llamada al Chain() después del primer elemento.

class Program 
{ 
    static void Main(string[] args) 
    { 
     if (2.Chain() < 3 < 4) 
     { 
      Console.WriteLine("Yay!"); 
     } 
    } 
} 

public class Chainable<T> where T : IComparable<T> 
{ 
    public Chainable(T value) 
    { 
     Value = value; 
     Failed = false; 
    } 

    public Chainable() 
    { 
     Failed = true; 
    } 

    public readonly T Value; 
    public readonly bool Failed; 

    public static Chainable<T> Fail { get { return new Chainable<T>(); } } 

    public static Chainable<T> operator <(Chainable<T> me, T other) 
    { 
     if (me.Failed) 
      return Fail; 

     return me.Value.CompareTo(other) == -1 
        ? new Chainable<T>(other) 
        : Fail; 
    } 

    public static Chainable<T> operator >(Chainable<T> me, T other) 
    { 
     if (me.Failed) 
      return Fail; 

     return me.Value.CompareTo(other) == 1 
        ? new Chainable<T>(other) 
        : Fail; 
    } 

    public static Chainable<T> operator ==(Chainable<T> me, T other) 
    { 
     if (me.Failed) 
      return Fail; 

     return me.Value.CompareTo(other) == 0 
        ? new Chainable<T>(other) 
        : Fail; 
    } 

    public static Chainable<T> operator !=(Chainable<T> me, T other) 
    { 
     if (me.Failed) 
      return Fail; 

     return me.Value.CompareTo(other) != 0 
        ? new Chainable<T>(other) 
        : Fail; 
    } 

    public static bool operator true(Chainable<T> me) 
    { 
     return !me.Failed; 
    } 

    public static bool operator false(Chainable<T> me) 
    { 
     return me.Failed; 
    } 

    public override bool Equals(object obj) 
    { 
     return Value.Equals(obj); 
    } 

    public override int GetHashCode() 
    { 
     return Value.GetHashCode(); 
    } 
} 

public static class ChainExt 
{ 
    public static Chainable<T> Chain<T>(this T value) where T : IComparable<T> 
    { 
     return new Chainable<T>(value); 
    } 
}