Come consumare le API standard instradate in modo pulito?

Una soluzione semplice con LINQ:

string CreatePath(params string[] segments)
{
    var includedSegments = segments.TakeWhile(segment => segment != null));
    return String.Join("/", includedSegments);
}

Quindi devi solo passare gli argomenti del segmento di stringa in ordine, convertiti in stringa. In alternativa puoi eseguire la conversione delle stringhe all'interno:

string CreatePath(params object[] segments)
{
    var includedSegments = segments.TakeWhile(segment => segment != null)).Select(segment => segment.ToString());
    return String.Join("/", includedSegments);
}

Puoi scrivere una soluzione fluente. Ha bisogno di alcune interfacce, ma l'utilizzo per un client è molto semplice e guidato, poiché il completamento automatico suggerisce automaticamente due possibilità in ogni punto: Immagini o sottocriteri, ad es. Sort (...);

Quindi per il cliente, l'utilizzo sarebbe simile a questo:

var g = // get gallerygetter from somewhere 

// get all images
var images = g.Get().Images;

// subsets
var images = g.Get().Section(section).Sort(sort).Images;

var images = g.Get()
    .Section(section)
    .Sort(sort)
    .Window(window)
    .ShowViral(showViral)
    .Page(page)
    .Images;

Ora ovviamente, per supportare un uso così piacevole, hai bisogno di alcune interfacce. Ma puoi implementare tutti quelli in una singola classe.

public interface IGallerySectionSortWindowShowViralPage : IGallery
{ 
    IGallery Page(int x);
}

public interface IGallerySectionSortWindowShowViral : IGallery
{
    IGallerySectionSortWindowShowViralPage ShowViral(bool x);
}

public interface IGallerySectionSortWindow : IGallery
{
    IGallerySectionSortWindowShowViral Window(Window w);
}

public interface IGallerySectionSort : IGallery
{
    IGallerySectionSortWindow Sort(Sort s);
}

public interface IGallerySection : IGallery
{
    IGallerySectionSort Section(Section s);
}

public IGallery
{
    Task<List<Image>> Images { get; }
}

public IGalleryGetter : IGallery
{
    IGallerySection Get();
}

public Gallery 
    : IGallery
    , IGalleryGetter
    , IGallerySection
    , IGallerySectionSort
    , IGallerySectionSortWindow
    , IGallerySectionSortWindowShowViral 
    , IGallerySectionSortWindowShowViralPage
{
    private string uri = "gallery";

    public Task<List<Image>> Images 
    {
        JObject response = await NetworkHelper.ExecuteRequest(uri);
        return response["data"].ToObject<List<Image>>();
    }

    public IGallerySection Get()
    {
        return this;
    }

    public IGallerySectionSort Section(Section section)
    {
        uri += "/" + section.ToString().ToLower();
        return this;
    }

    public IGallerySectionSortWindow Sort(Sort sort)
    {
        uri += "/" + sort.ToString().ToLower();
        return this;
    }

    public IGallerySectionSortWindowShowViral Window(Window window)
    {
        uri += "/" + window.ToString().ToLower();
        return this;
    }

    public IGallerySectionSortWindowShowViralPage ShowViral(bool show_viral)
    {
        uri += "/" + show_viral.ToString().ToLower();
        return this;
    }

    public IGallery Page(int page)
    {
        uri += "/" + page.ToString().ToLower();
        return this;
    } 

}

Puoi migliorare questo metodo separando il metodo di unione dei percorsi.

public static string BuildPath(params object[] paths) {
    string result = "";
    if (paths != null) {        
        foreach(var path in paths) {
            if (path == null) break;
            result += "/" + path;
        }
    }
    return result;
}

Quindi la tua implementazione avrà più senso, perché è one-liner

string uri = BuildPath("gallery", section, sort, window, showViral, page);

Ho fatto questo in un violinista qui: link . Si noti che questo è l'imitazione del comportamento del codice e non esegue la codifica del percorso URL.