沒有通用擴展方法的類型推斷

Question

我有以下方法：

public static TEventInvocatorParameters Until
    <TEventInvocatorParameters, TEventArgs>(this TEventInvocatorParameters p,
                                            Func<TEventArgs, bool> breakCond)
    where TEventInvocatorParameters : EventInvocatorParameters<TEventArgs>
    where TEventArgs : EventArgs
{
    p.BreakCondition = breakCond;
    return p;
}

而這堂課

public class EventInvocatorParameters<T>
    where T : EventArgs
{
    public Func<T, bool> BreakCondition { get; set; }
    // Other properties used below omitted for brevity.
}

現在，我有以下問題：

1. 此擴展方法顯示在所有類型上，甚至string 。
2. 我不能寫new EventInvocatorParameters<EventArgs>(EventABC).Until(e => false); 它告訴我“方法的類型參數......無法從用法中推斷出來。”

我不能像這樣使用泛型類型參數嗎？ 你會如何解決這個問題？
重要的一點：我需要這兩個泛型參數，因為我需要返回調用此擴展方法的相同類型。

---

更廣泛的圖片（不是回答問題所必需的！）：
我正在嘗試創建一個流暢的界面來調用事件。 基礎是這個靜態類：

public static class Fire
{
   public static void Event<TEventArgs>(
       ConfiguredEventInvocatorParameters<TEventArgs> parameters)
    where TEventArgs : EventArgs
    {
        if (parameters.EventHandler == null)
        {
            return;
        }

        var sender = parameters.Sender;
        var eventArgs = parameters.EventArgs;
        var breakCondition = parameters.BreakCondition;

        foreach (EventHandler<TEventArgs> @delegate in 
                 parameters.EventHandler.GetInvocationList())
        {
            try
            {
                @delegate(sender, eventArgs);
                if (breakCondition(eventArgs))
                {
                    break;
                }
            }
            catch (Exception e)
            {
                var exceptionHandler = parameters.ExceptionHandler;
                if (!exceptionHandler(e))
                {
                    throw;
                }
            }
        }
    }
}

為了確保這種方法只能用完全配置的參數來調用，它僅接受一個ConfiguredEventInvocatorParameters<T>其中導出從EventInvocatorParameters<T>

public class ConfiguredEventInvocatorParameters<T>
    : EventInvocatorParameters<T>
    where T : EventArgs
{
    public ConfiguredEventInvocatorParameters(
        EventInvocatorParameters<T> parameters, object sender, T eventArgs)
        : base(parameters)
    {
        EventArgs = eventArgs;
        Sender = sender;
    }

    public T EventArgs { get; private set; }
    public object Sender { get; private set; }

}

以下是有效的調用：

Fire.Event(EventName.With(sender, eventArgs));
Fire.Event(EventName.With(sender, eventArgs).Until(e => e.Cancel));
Fire.Event(EventName.Until(e => e.Cancel).With(sender, eventArgs));

以下內容無效：

// no sender or eventArgs have been specified, i.e. missing call to With(...)
Fire.Event(EventName.Until(e => e.Cancel));

為了完成這項工作，存在名為With擴展方法，它們接受EventHandler<TEventArgs或TEventInvocatorParameters並返回ConfiguredEventInvocatorParameters<TEventArgs> 。 With now 之后的所有調用也需要返回類型ConfiguredEventInvocatorParameters<TEventArgs> ，否則有效調用的第二個示例（以Until結尾）將不起作用。
如果您對 API 有任何想法，請告訴我。 但是，我想避免以下三件事：

• 如果參數尚未完全配置，則僅在運行時失敗
• 創建一個像EventName.With(...).Until(...).Fire()這樣的反向語法
• 使用臭名昭著的Do方法開始： Fire(EventName).With(...).Until(...).Do();

Answer 1

2020 年 11 月更新：以下原始答案寫於 2011 年； 泛型方法類型推斷、重載解析以及方法的“最終驗證”如何完成的規則​​在最近的 C# 版本中發生了微小但顯着的變化； 這個答案，以及我原來的 MSDN 博客上關於它的存檔文章的鏈接可能不再准確。 此外，微軟出於法律原因刪除了對原始文章的評論； 這些評論中有大量的背景和討論。 我希望在某個時候有時間重新閱讀這篇文章，以澄清 (1) 今天的規則，(2) 它們是如何改變的，以及 (3) 在那些被刪除的評論中討論的想法如何影響這些決定，但這很多工作，我可能在一段時間內無法完成。 請記住，自 2012 年 11 月以來，我一直沒有加入 C# 語言設計團隊。

---

泛型方法的類型推斷故意不使從限制任何扣減。 相反，從參數和形式參數中進行推導，然后根據約束檢查推導的類型參數。

有關約束和方法簽名的一些設計問題的詳細討論，包括幾十個人告訴我認為現有設計是明智的錯誤，請參閱我關於該主題的文章：

https://docs.microsoft.com/en-gb/archive/blogs/ericlippert/constraints-are-not-part-of-the-signature

Answer 2

對於任何感興趣的人，現在，我使用通用類層次結構解決了原始問題（流暢的事件調用 API）。 這基本上是 Hightechrider 對類固醇的回答。

public abstract class EventInvocatorParametersBase
    <TEventInvocatorParameters, TEventArgs>
    where TEventArgs : EventArgs
    where TEventInvocatorParameters :
        EventInvocatorParametersBase<TEventInvocatorParameters, TEventArgs>

{
    protected EventInvocatorParametersBase(
        EventHandler<TEventArgs> eventHandler,
        Func<Exception, bool> exceptionHandler,
        Func<TEventArgs, bool> breakCondition)
    {
        EventHandler = eventHandler;
        ExceptionHandler = exceptionHandler;
        BreakCondition = breakCondition;
    }

    protected EventInvocatorParametersBase(
        EventHandler<TEventArgs> eventHandler)
        : this(eventHandler, e => false, e => false)
    {
    }

    public Func<TEventArgs, bool> BreakCondition { get; set; }
    public EventHandler<TEventArgs> EventHandler { get; set; }
    public Func<Exception, bool> ExceptionHandler { get; set; }

    public TEventInvocatorParameters Until(
        Func<TEventArgs, bool> breakCondition)
    {
        BreakCondition = breakCondition;
        return (TEventInvocatorParameters)this;
    }

    public TEventInvocatorParameters WithExceptionHandler(
        Func<Exception, bool> exceptionHandler)
    {
        ExceptionHandler = exceptionHandler;
        return (TEventInvocatorParameters)this;
    }

    public ConfiguredEventInvocatorParameters<TEventArgs> With(
        object sender, 
        TEventArgs eventArgs)
    {
        return new ConfiguredEventInvocatorParameters<TEventArgs>(
            EventHandler, ExceptionHandler, BreakCondition,
            sender, eventArgs);
    }
}

public class EventInvocatorParameters<T> :
    EventInvocatorParametersBase<EventInvocatorParameters<T>, T>
    where T : EventArgs
{
    public EventInvocatorParameters(EventHandler<T> eventHandler)
        : base(eventHandler)
    {
    }
}

public class ConfiguredEventInvocatorParameters<T> :
    EventInvocatorParametersBase<ConfiguredEventInvocatorParameters<T>, T>
    where T : EventArgs
{
    public ConfiguredEventInvocatorParameters(
        EventHandler<T> eventHandler,
        Func<Exception, bool> exceptionHandler,
        Func<T, bool> breakCondition, object sender,
        T eventArgs)
        : base(eventHandler, exceptionHandler, breakCondition)
    {
        EventArgs = eventArgs;
        Sender = sender;
    }

    public ConfiguredEventInvocatorParameters(EventHandler<T> eventHandler,
                                              object sender,
                                              T eventArgs)
        : this(eventHandler, e => false, e => false, sender, eventArgs)
    {
    }

    public T EventArgs { get; private set; }
    public object Sender { get; private set; }
}

public static class EventExtensions
{
    public static EventInvocatorParameters<TEventArgs> Until<TEventArgs>(
        this EventHandler<TEventArgs> eventHandler,
        Func<TEventArgs, bool> breakCondition)
        where TEventArgs : EventArgs
    {
        return new EventInvocatorParameters<TEventArgs>(eventHandler).
            Until(breakCondition);
    }

    public static EventInvocatorParameters<TEventArgs> 
        WithExceptionHandler<TEventArgs>(
            this EventHandler<TEventArgs> eventHandler,
            Func<Exception, bool> exceptionHandler)
        where TEventArgs : EventArgs
    {
        return
            new EventInvocatorParameters<TEventArgs>(eventHandler).
                WithExceptionHandler(exceptionHandler);
    }

    public static ConfiguredEventInvocatorParameters<TEventArgs>
        With<TEventArgs>(
            this EventHandler<TEventArgs> eventHandler, object sender,
            TEventArgs eventArgs)
        where TEventArgs : EventArgs
    {
        return new ConfiguredEventInvocatorParameters<TEventArgs>(
            eventHandler, sender, eventArgs);
    }
}

這允許您編寫如下代碼：

Fire.Event(EventName.WithExceptionHandler(e => false)
                    .Until(e => false).With(this, EventArgs.Empty));
Fire.Event(EventName.With(this, EventArgs.Empty));
Fire.Event(EventName.WithExceptionHandler(e => false)
                    .With(this, EventArgs.Empty).Until(e => false));
Fire.Event(EventName.With(this, EventArgs.Empty)
                    .WithExceptionHandler(e => false).Until(e => false));

但它不允許你寫這個，因為沒有提供所有必要的信息（eventArgs 和 sender）：

Fire.Event(EventName.Until(e => false));
Fire.Event(EventName);

Answer 3

有什么理由需要使用擴展方法嗎？ 如果你把Until EventInvocatorParameters<T>類，你可以避免提到的兩個問題：

public class EventInvocatorParameters<T>
    where T : EventArgs
{
    public Func<T, bool> BreakCondition { get; set; }
    // Other properties used below omitted for brevity.

    public EventInvocatorParameters<T> Until (Func<T, bool> breakCond)
    {
        this.BreakCondition = breakCond;
        return this;
    }
}

Answer 4

我知道有點逃避，但是您是否考慮過使用Rx ，而不是重新發明您似乎想要做的事情？