你所描述的被称为流畅接口。
LINQ 函数是具有以下签名的扩展函数。
IEnumerable<T> someFunction<T>(this IEnumerable<T>, ...)
如您所见,这是一个普通的函数,返回某些内容...
流畅接口通过返回实现枚举接口的内容来使用它,在这种情况下,还使用返回类型来改变您可以在结果上调用的函数集合...
以下是一个示例程序...
using System.Collections;
using System.Collections.Generic;
using System.Linq;
namespace SoFluentExample
{
class Program
{
static void Main(string[] args)
{
var en = Enumerable.Range(0, 10).Concat(Enumerable.Range(0, 10));
var result = en
.ReplaceAll(1, 100)
.Given(true)
.ReplaceAll(2, 200)
.Given(false)
.ReplaceAll(3,300)
.ToArray();
}
}
public class MyFluentEnumerableWithCondition<T> : IEnumerable<T>
{
public IEnumerable<T> en { get; private set; }
public bool condition { get; private set; }
public MyFluentEnumerableWithCondition(IEnumerable<T> en, bool condition)
{
this.en = en;
this.condition = condition;
}
public IEnumerator<T> GetEnumerator()
{
return en.GetEnumerator();
}
IEnumerator IEnumerable.GetEnumerator()
{
return en.GetEnumerator();
}
}
public class MyFluentReplacerEnumerable<T> : IEnumerable<T>
{
private IEnumerable<T> en;
private T foo;
private T bar;
public MyFluentReplacerEnumerable(IEnumerable<T> en, T foo, T bar)
{
this.en = en;
this.foo = foo;
this.bar = bar;
}
public IEnumerator<T> GetEnumerator()
{
return new MyEnumerator(en.GetEnumerator(), foo, bar);
}
IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
private class MyEnumerator : IEnumerator<T>
{
private IEnumerator<T> en;
private T foo;
private T bar;
public MyEnumerator(IEnumerator<T> enumerator,T foo, T bar)
{
this.en = enumerator;
this.foo = foo;
this.bar = bar;
}
public T Current => replace(en.Current,foo,bar);
private T replace(T current, T foo, T bar)
{
return current.Equals(foo) ? bar : current;
}
object IEnumerator.Current => Current;
public bool MoveNext()
{
return en.MoveNext();
}
public void Reset()
{
en.Reset();
}
#region IDisposable Support
private bool disposedValue = false;
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
en.Dispose();
}
disposedValue = true;
}
}
public void Dispose()
{
Dispose(true);
}
#endregion
}
}
public static class MyExtension
{
public static IEnumerable<T> ReplaceAll<T>(this IEnumerable<T> en,T foo, T bar)
{
return new MyFluentReplacerEnumerable<T>(en, foo, bar);
}
public static MyFluentEnumerableWithCondition<T> ReplaceAll<T>(this MyFluentEnumerableWithCondition<T> en, T foo, T bar)
{
if (!en.condition)
return en;
return new MyFluentEnumerableWithCondition<T>(en.en.ReplaceAll(foo,bar),true);
}
public static MyFluentEnumerableWithCondition<T> Given<T>(this IEnumerable<T> en, bool condition)
{
return new MyFluentEnumerableWithCondition<T>(en, condition);
}
}
}
ReplaceAll
被定义在 IEnumerable<T>
和 MyFluentEnumerableWithCondition<T>
中,具体实现由类型决定,即使 MyFluentEnumerableWithCondition<T>
实现了 IEnumerable<T>
,更具体的签名仍然被使用。
ReplaceAll
是什么意思,它与LINQ有什么关系? - Panagiotis Kanavos.Given
方法在List上设置或重置某种标志并返回List,然后.ReplaceAll
“神奇地”知道该标志并理解如果已设置或未设置该标志,则不应执行任何操作时,您提出的想法才有可能实现。如果这一切都是关于标准的List<T>
,那么坏消息是它不包含可以设置的此类标志。 - Peter B