Question concernant interface fluide en C#

Question

J'ai la classe suivante:

public class Fluently 
{ 
    public Fluently Is(string lhs) 
    { 
    return this; 
    } 
    public Fluently Does(string lhs) 
    { 
    return this; 
    } 
    public Fluently EqualTo(string rhs) 
    { 
    return this; 
    } 
    public Fluently LessThan(string rhs) 
    { 
    return this; 
    } 
    public Fluently GreaterThan(string rhs) 
    { 
    return this; 
    } 
} 

En grammaire anglaise, vous ne pouvez pas avoir « est quelque chose d'égal à quelque chose » ou « fait quelque chose de plus que quelque chose », donc je ne suis pas veulent que Is.EqualTo et Does.GreaterThan soient possibles. Y a-t-il un moyen de le restreindre?

var f = new Fluently(); 
f.Is("a").GreaterThan("b"); 
f.Is("a").EqualTo("b");  //grammatically incorrect in English 
f.Does("a").GreaterThan("b"); 
f.Does("a").EqualTo("b");  //grammatically incorrect in English 

Merci!

Answer 1

Pour appliquer ce genre de chose, vous aurez besoin de plusieurs types (pour limiter ce qui est disponible à partir de quel contexte) - ou au moins quelques interfaces:

public class Fluently : IFluentlyDoes, IFluentlyIs 
{ 
    public IFluentlyIs Is(string lhs) 
    { 
     return this; 
    } 
    public IFluentlyDoes Does(string lhs) 
    { 
     return this; 
    } 
    Fluently IFluentlyDoes.EqualTo(string rhs) 
    { 
     return this; 
    } 
    Fluently IFluentlyIs.LessThan(string rhs) 
    { 
     return this; 
    } 
    Fluently IFluentlyIs.GreaterThan(string rhs) 
    { 
     return this; 
    } 
} 
public interface IFluentlyIs 
{ 
    Fluently LessThan(string rhs); 
    Fluently GreaterThan(string rhs); 
} 
public interface IFluentlyDoes 
{ // grammar not included - this is just for illustration! 
    Fluently EqualTo(string rhs); 
} 

Answer 2

Ma solution serait

public class Fluently 
{ 
    public FluentlyIs Is(string lhs) 
    { 
     return this; 
    } 
    public FluentlyDoes Does(string lhs) 
    { 
     return this; 
    } 
} 

public class FluentlyIs 
{ 
    FluentlyIs LessThan(string rhs) 
    { 
     return this; 
    } 
    FluentlyIs GreaterThan(string rhs) 
    { 
     return this; 
    } 
} 

public class FluentlyDoes 
{ 
    FluentlyDoes EqualTo(string rhs) 
    { 
     return this; 
    } 
} 

Tout à fait similaire à Gravell, mais légèrement plus simple à comprendre, à mon avis.