Anonymous inner classes en C#

C'est ce que je ferais:

Conserver un Lien comme une classe abstraite, l'utilisation d'une Usine d'instancier et de passer dans votre fermeture d'une méthode anonyme en tant que paramètre de l'Usine de construction de la méthode. De cette façon, vous pouvez conserver votre design original avec un Lien comme une classe abstraite, forçant la mise en œuvre à travers l'usine, et cachent encore des trace de Lien à l'intérieur de l'usine.

Voici un exemple de code:

class Program
{
    static void Main(string[] args)
    {

        Link link = LinkFactory.GetLink("id", () =>
        //This would be your onClick method.
        {
                //SetResponsePage(...);
                Console.WriteLine("Clicked");
                Console.ReadLine();
        });
        link.FireOnClick();
    }
    public static class LinkFactory
    {
        private class DerivedLink : Link
        {
            internal DerivedLink(String id, Action action)
            {
                this.ID = id;
                this.OnClick = action;
            }
        }
        public static Link GetLink(String id, Action onClick)
        {
                return new DerivedLink(id, onClick);
        }
    }
    public abstract class Link
    {
        public void FireOnClick()
        {
            OnClick();
        }
        public String ID
        {
            get;
            set;
        }
        public Action OnClick
        {
            get;
            set;
        }
    }
}

EDIT: Fait, C'est peut être un peu plus proche de ce que vous voulez:

Link link = new Link.Builder
{
    OnClick = () =>
    {
        //SetResponsePage(...);
    },
    OnFoo = () =>
    {
        //Foo!
    }
}.Build("id");

La beauté est-il utilise un bloc init, vous permettant de déclarer autant de facultatif implémentations des actions au sein de la classe Link que vous le souhaitez.

Voici le Lien de la classe (Avec scellé Générateur interne de la classe).

public class Link
{
    public sealed class Builder
    {
        public Action OnClick;
        public Action OnFoo;
        public Link Build(String ID)
        {
            Link link = new Link(ID);
            link.OnClick = this.OnClick;
            link.OnFoo = this.OnFoo;
            return link;
        }
    }
    public Action OnClick;
    public Action OnFoo;
    public String ID
    {
        get;
        set;
    }
    private Link(String ID)
    {
        this.ID = ID;
    }
}

C'est proche de ce que vous cherchez, mais je pense que nous pouvons prendre une étape supplémentaire avec option arguments nommés, C# 4.0 feature. Regardons l'exemple de la déclaration de Lien avec, en option, les arguments nommés:

Link link = Link.Builder.Build("id",
    OnClick: () =>
    {
        //SetResponsePage(...);
        Console.WriteLine("Click!");
    },
    OnFoo: () =>
    {
        Console.WriteLine("Foo!");
        Console.ReadLine();
    }
);

Pourquoi est-ce cool? Regardons la nouvelle classe Link:

public class Link
{
    public static class Builder
    {
        private static Action DefaultAction = () => Console.WriteLine("Action not set.");
        public static Link Build(String ID, Action OnClick = null, Action OnFoo = null, Action OnBar = null)
        {
            return new Link(ID, OnClick == null ? DefaultAction : OnClick, OnFoo == null ? DefaultAction : OnFoo, OnBar == null ? DefaultAction : OnBar);
        }
    }
    public Action OnClick;
    public Action OnFoo;
    public Action OnBar;
    public String ID
    {
        get;
        set;
    }
    private Link(String ID, Action Click, Action Foo, Action Bar)
    {
        this.ID = ID;
        this.OnClick = Click;
        this.OnFoo = Foo;
        this.OnBar = Bar;
    }
}

À l'intérieur de la classe statique Builder, il y a une usine méthode Build qui prend en 1 paramètre requis (L'ID) et 3 paramètres facultatifs, OnClick, OnFoo et OnBar. Si ils ne sont pas affectés, la méthode de fabrique, leur donne une implémentation par défaut.

Donc dans votre constructeur de paramètre d'arguments pour le Lien, vous êtes tenu de mettre en œuvre les méthodes que vous avez besoin, sinon ils vont utiliser l'action par défaut, ce qui pourrait n'être rien.

L'inconvénient, cependant, est dans le dernier exemple, le Lien de la classe n'est pas abstrait. Mais il ne peut pas être instanciée à l'extérieur de la portée de la Liaison de la classe, parce que son constructeur est privé (Forcer l'utilisation du Constructeur de la classe à instancier Lien).

Vous pouvez également déplacer l'option paramètres dans le Lien du constructeur directement, en évitant la nécessité d'une usine complètement.