没有类型推断与泛型扩展方法 [英] No type inference with generic extension method
问题描述
我有以下方法:
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.
}
现在,我有以下问题:
- 在此扩展方法显示在所有类型,甚至
字符串
。 - 在我可以不写
新EventInvocatorParameters&LT; EventArgs的&GT;(EventABC)。直到(E =&GT;假);
这是告诉我的方法类型参数。 ..不能从使用的推断。
- This extension method shows on all types, even
string
. - I can't write
new EventInvocatorParameters<EventArgs>(EventABC).Until(e => false);
It is telling me "The type arguments for method ... cannot be inferred from the usage."
我不能使用泛型类型参数也是这样吗?你会如何解决这个问题?
重要的一点:我需要这两个通用的参数,因为我需要返还相同种类这种扩展方法被称为对
Can't I use generic type parameters like this? How would you resolve this problem?
Important point: I need both of those generic parameters, because I need to return the same type this extension method was called on.
退一步海阔天空(没有必要回答这个问题!):
我想创建一个流畅的接口调用的事件。该基地是这个静态类:
Broader picture (not necessary for answering the question!):
I am trying to create a fluent interface to invoking events. The base is this static class:
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&LT; T&GT;
这源于 EventInvocatorParameters&LT; T&GT ;
:
To make sure this method can only be called with fully configured parameters, it only accepts a ConfiguredEventInvocatorParameters<T>
which derives from 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; }
}
以下将是有效的电话:
The following would be valid calls:
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));
以下是无效的:
The following would be invalid:
// no sender or eventArgs have been specified, i.e. missing call to With(...)
Fire.Event(EventName.Until(e => e.Cancel));
,存在一个名为在
扩展方法,即接受一个事件处理程序和LT为了使这项工作; TEventArgs
或 TEventInvocatorParameters
并返回 ConfiguredEventInvocatorParameters&LT; TEventArgs&GT;
。所有来电继在
现在还需要返回值的类型 ConfiguredEventInvocatorParameters&LT; TEventArgs&GT;
,一个有效的,否则第二个例子(末尾与到
)调用是行不通的。照片
如果在一般的API有什么想法,请让我知道。不过,我想避免以下三件事情:
To make this work, there exist extension methods named With
, that accept either a EventHandler<TEventArgs
or a TEventInvocatorParameters
and return a ConfiguredEventInvocatorParameters<TEventArgs>
. All calls following the With
now also need to return the type ConfiguredEventInvocatorParameters<TEventArgs>
, otherwise the second example of a valid call (with the Until
at the end) wouldn't work.
If you have any thoughts on the API in general, please let me know. However, I want to avoid the following three things:
- 在故障只在运行时,如果参数还没有被完全配置
- 创建像
EventName.With逆语法(...),直到(...)。火灾()
- 使用臭名昭著的
不要
方法来开始的事情:火(事件名称)。随着(...)直到(...) 。做();
- Fail only at runtime if the parameters have not been configured fully
- Creating an inverse syntax like
EventName.With(...).Until(...).Fire()
- Use the infamous
Do
method to start off things:Fire(EventName).With(...).Until(...).Do();
推荐答案
对于有兴趣的人,现在,我解决了一个通用的类层次结构的原始问题(流利事件调用API)。这基本上是对类固醇Hightechrider的答案。
For anyone interested, for now, I solved the original problem (fluent event invocation API) with a generic class hierarchy. This is basically Hightechrider's answer on steroids.
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);
}
}
这允许你写code是这样的:
This allows you to write code like this:
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的和发件人)已经提供了:
But it doesn't allow you to write this, because not all necessary info (eventArgs and sender) has been provided:
Fire.Event(EventName.Until(e => false));
Fire.Event(EventName);
这篇关于没有类型推断与泛型扩展方法的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持IT屋!