Posso creare operatori ternari in C#?

Question

Voglio creare un operatore ternario per un < b < c che è un < b & & b < c. o qualsiasi altra opzione si può pensare che un < b> c e così via ... Sono un fan delle mie shortform e ho voluto crearlo da quando ho imparato a programmare al liceo.

Come?

Answer 1

Hai provato a cercare operatori ternari in google per vedere se qualcosa esiste già?

Answer 2

Non puoi farlo. È possibile implementare solo operatori esistenti e non vi è alcun ternario. <. <. operatore in C#.

Inoltre, tale operatore sarebbe ambiguo con gli operatori di confronto esistenti. Ad esempio, l'espressione a == b == c == d significa ((a == b) == c) == d o (a == b == c) == d?

Answer 3

No. Non in C#. L'estensione della lingua in questo modo non è disponibile in nessuna versione corrente di C#, ma Luca Bolognese ha sottolineato l'utilizzo del compilatore come servizio e alcune funzionalità che potrebbero consentire di estendere la lingua in questo modo: http://microsoftpdc.com/Sessions/FT11.

Answer 4

Se si vuole fare questo per i tipi di dati primitivi, sei sfortunato. C# non supporta l'aggiunta di operatori a questi.

Nei propri tipi di dati è possibile restituire un tipo di dati speciale che memorizza il risultato intermedio e il risultato di confronto. Tuttavia, ti suggerisco di attenersi al linguaggio C# - se vuoi davvero lo stile operatore a < b < c, passa a Python.

Answer 5

Siamo spiacenti, non è possibile creare i propri operatori in C#.

Si potrebbe utilizzare metodi di estensione per consentire una sintassi fluente come

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

Oppure, se si dovesse essere estremamente intelligente, si potrebbe fare:

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

così facendo è difficile, ma possibile. (Suggerimento: definire un oggetto personalizzato restituito da IsLessThan che ne tiene traccia dei limiti e comprende come è combinato con altre istanze dell'oggetto. Essenzialmente, questo è il modo in cui LINQ-to-SQL funziona per combinare Dove, Seleziona e così via.)

Ma non è possibile definire le proprie sintassi dell'operatore in C#.

Se sei interessato alle lingue in cui puoi definire i tuoi operatori, potresti considerare di esaminare F #.

Answer 6

Non credete alle nemici;)

È possibile farlo in C#. Ecco un esempio di implementazione — Ho basato il concatenamento sul modo in cui lo fa Icon ... se un confronto ha esito positivo, il risultato è quello del parametro giusto, altrimenti viene restituito un risultato "non riuscito" speciale.

L'unica sintassi aggiuntiva che è necessario utilizzare è la chiamata a Chain() dopo il primo 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); 
    } 
}