MarketRuleHelper — StockSharp 文档

ActiveRule

public static void ActiveRule(IMarketRuleContainer container, IMarketRule rule, Func<bool> process)

MarketRuleHelper.ActiveRule(container, rule, process)

以活活法则.

container: 规则容器。
rule: 规则。
process: 接取者.

AddRuleLog

public static void AddRuleLog(IMarketRuleContainer container, LogLevels level, IMarketRule rule, string message, object[] args)

MarketRuleHelper.AddRuleLog(container, level, rule, message, args)

从法出写出教谕.

container: 规则容器。
level: 日志消息的级别。
rule: 规则。
message: 腾讯网.
args: 文本消息设置。如果信件是格式字符串, 则使用。详情见 Object[ ] 。

And

public static IMarketRule And(IEnumerable<IMarketRule> rules)

result = MarketRuleHelper.And(rules)

将规则和条件结合起来

rules: 规矩

返回值: 合并规则。

And

public static IMarketRule And(IMarketRule rule, IMarketRule[] rules)

result = MarketRuleHelper.And(rule, rules)

将规则和条件结合起来

rule: 初一通义.
rules: 附加规则。

返回值: 合并规则。

And``2

public static MarketRule<TToken, TArg> And<TToken, TArg>(MarketRule<TToken, TArg> rule, MarketRule<TToken, TArg>[] rules)

result = MarketRuleHelper.And(rule, rules)

将规则和条件结合起来

rule: 初一通义.
rules: 附加规则。

返回值: 合并规则。

Apply

public static IMarketRule Apply(IMarketRule rule, IMarketRuleContainer container)

result = MarketRuleHelper.Apply(rule, container)

To form a rule (include IsReady).

rule: 规则。
container: 规则容器。

返回值: 规则。

Apply

public static IMarketRule Apply(IMarketRule rule)

result = MarketRuleHelper.Apply(rule)

To form a rule (include IsReady).

rule: 规则。

返回值: 规则。

Apply``2

public static MarketRule<TToken, TArg> Apply<TToken, TArg>(MarketRule<TToken, TArg> rule)

result = MarketRuleHelper.Apply(rule)

To form a rule (include IsReady).

rule: 规则。

返回值: 规则。

Apply``2

public static MarketRule<TToken, TArg> Apply<TToken, TArg>(MarketRule<TToken, TArg> rule, IMarketRuleContainer container)

result = MarketRuleHelper.Apply(rule, container)

To form a rule (include IsReady).

rule: 规则。
container: 规则容器。

返回值: 规则。

Changed

public static MarketRule<Position, Position> Changed(Position position, IPositionProvider provider)

result = MarketRuleHelper.Changed(position, provider)

创建位置变化事件的规则。

position: 更改事件要追踪的位置。
provider: 位置提供商.

返回值: 规则。

Exclusive

public static void Exclusive(IMarketRule rule1, IMarketRule rule2)

MarketRuleHelper.Exclusive(rule1, rule2)

使规则相互排斥。

rule1: 初一通义.
rule2: 二通相相相通相相通相通相通相通相通相通相通相通相通相通相通相通相通相通相通相通相通相通相通相通相通相通相通相通相通相通相通相通相通相通相通相通相通相通相通相通相通相通相通相通相相通相通相通相通相通相相通相通相相通相通相相相相通相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相

Once``1

public static TRule Once<TRule>(TRule rule)

result = MarketRuleHelper.Once(rule)

使规则成为一次性规则(将只被叫出一次).

rule: 规则。

返回值: 规则。

Or

public static IMarketRule Or(IMarketRule rule, IMarketRule[] rules)

result = MarketRuleHelper.Or(rule, rules)

以OR条件结合规则.

rule: 初一通义.
rules: 附加规则。

返回值: 合并规则。

Or

public static IMarketRule Or(IEnumerable<IMarketRule> rules)

result = MarketRuleHelper.Or(rules)

以OR条件结合规则.

rules: 规矩

返回值: 合并规则。

Or``2

public static MarketRule<TToken, TArg> Or<TToken, TArg>(MarketRule<TToken, TArg> rule, MarketRule<TToken, TArg>[] rules)

result = MarketRuleHelper.Or(rule, rules)

以OR条件结合规则.

rule: 初一通义.
rules: 附加规则。

返回值: 合并规则。

SuspendRules

public static void SuspendRules(Action action)

MarketRuleHelper.SuspendRules(action)

要在悬浮模式中处理规则( 例如创建若干规则并同时启动规则 ) 。在方法操作完成后, 附加在容器上的规则会恢复活性。

action: 暂停规则处理的动作。例如, 要同时添加若干规则。

SuspendRules

public static void SuspendRules(IMarketRuleContainer container, Action action)

MarketRuleHelper.SuspendRules(container, action)

要在悬浮模式中处理规则( 例如创建若干规则并同时启动规则 ) 。在方法操作完成后, 附加在容器上的规则会恢复活性。

container: 规则容器。
action: 暂停规则处理的动作。例如, 要同时添加若干规则。

Suspend``1

public static TRule Suspend<TRule>(TRule rule, bool suspend)

result = MarketRuleHelper.Suspend(rule, suspend)

暂停或恢复规则。

rule: 规则。
suspend: -暂停休演

返回值: 规则。

TryRemoveRule

public static bool TryRemoveRule(IMarketRuleContainer container, IMarketRule rule, bool checkCanFinish)

result = MarketRuleHelper.TryRemoveRule(container, rule, checkCanFinish)

删除规则。如果在调用此方法时执行规则, 则不会删除。

container: 规则容器。
rule: 规则。
checkCanFinish: 检查暂停执行规则的可能性。

返回值: ,如果一条规则被成功删除,如果一条规则目前无法被删除。

TryRemoveWithExclusive

public static bool TryRemoveWithExclusive(IMarketRuleContainer container, IMarketRule rule)

result = MarketRuleHelper.TryRemoveWithExclusive(container, rule)

删除规则和所有相反的规则。如果规则在唤起此方法时被执行,则规则将不会被删除。

container: 规则容器。
rule: 规则。

返回值: 如果规则被取消, 否则,

UpdateLogLevel``1

public static TRule UpdateLogLevel<TRule>(TRule rule, LogLevels level)

result = MarketRuleHelper.UpdateLogLevel(rule, level)

以定取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取取

rule: 规则。
level: 伐木的级别。

返回值: 规则。

UpdateName``1

public static TRule UpdateName<TRule>(TRule rule, string name)

result = MarketRuleHelper.UpdateName(rule, name)

要指定规则的新名称。

rule: 规则。
name: 规则新名.

返回值: 规则。

WhenAllTrades

public static MarketRule<Order, IEnumerable<MyTrade>> WhenAllTrades(Order order, ISubscriptionProvider provider)

result = MarketRuleHelper.WhenAllTrades(order, provider)

建立规则,用于命令所有行业的发生事件。

order: 所有交易的发生事件都要追踪的顺序.
provider: 交易提供商.

返回值: 规则。

WhenBestAskPriceLess

public static MarketRule<Subscription, IOrderBookMessage> WhenBestAskPriceLess(Subscription subscription, ISubscriptionProvider provider, decimal level)

result = MarketRuleHelper.WhenBestAskPriceLess(subscription, provider, level)

创建规则,用于将最佳报价降至特定级别以下的事件。

subscription: 订阅
provider: ISubscriptionProvider
level: 关上

返回值: 规则。

WhenBestAskPriceMore

public static MarketRule<Subscription, IOrderBookMessage> WhenBestAskPriceMore(Subscription subscription, ISubscriptionProvider provider, decimal level)

result = MarketRuleHelper.WhenBestAskPriceMore(subscription, provider, level)

制定规则,处理超过特定级别最佳报价的事件。

subscription: 订阅
provider: ISubscriptionProvider
level: 关上

返回值: 规则。

WhenBestBidPriceLess

public static MarketRule<Subscription, IOrderBookMessage> WhenBestBidPriceLess(Subscription subscription, ISubscriptionProvider provider, decimal level)

result = MarketRuleHelper.WhenBestBidPriceLess(subscription, provider, level)

制定将最佳出价降至特定水平以下事件的规则。

subscription: 订阅
provider: ISubscriptionProvider
level: 关上

返回值: 规则。

WhenBestBidPriceMore

public static MarketRule<Subscription, IOrderBookMessage> WhenBestBidPriceMore(Subscription subscription, ISubscriptionProvider provider, decimal level)

result = MarketRuleHelper.WhenBestBidPriceMore(subscription, provider, level)

制定具体级别最佳出价超标事件规则.

subscription: 订阅
provider: ISubscriptionProvider
level: 关上

返回值: 规则。

WhenCanceled

public static MarketRule<Order, Order> WhenCanceled(Order order, ISubscriptionProvider provider)

result = MarketRuleHelper.WhenCanceled(order, provider)

创建命令取消事件的规则。

order: 取消活动的顺序。
provider: 交易提供商.

返回值: 规则。

WhenCancelFailed

public static MarketRule<Order, OrderFail> WhenCancelFailed(Order order, ISubscriptionProvider provider)

result = MarketRuleHelper.WhenCancelFailed(order, provider)

创建一条规则, 用于取消交换命令失败的事件。

order: 取消失败事件的命令要追查。
provider: 交易提供商.

返回值: 规则。

WhenCandleReceived

public static MarketRule<Subscription, ICandleMessage> WhenCandleReceived(Subscription subscription, ISubscriptionProvider provider)

result = MarketRuleHelper.WhenCandleReceived(subscription, provider)

为 CandleReceived 事件创建规则。

subscription: 订阅.
provider: 订阅提供者.

返回值: 规则。

WhenCandleReceived``1

public static MarketRule<Subscription, TCandle> WhenCandleReceived<TCandle>(Subscription subscription, ISubscriptionProvider provider)

result = MarketRuleHelper.WhenCandleReceived(subscription, provider)

为 CandleReceived 事件创建规则。

subscription: 订阅.
provider: 订阅提供者.

返回值: 规则。

WhenCandlesChanged

public static MarketRule<Subscription, ICandleMessage> WhenCandlesChanged(ISubscriptionProvider subscriptionProvider, Subscription subscription)

result = MarketRuleHelper.WhenCandlesChanged(subscriptionProvider, subscription)

以创烛之变事之规.

subscriptionProvider: 订阅经理.
subscription: 蜡烛系列要追踪到改变后的蜡烛.

返回值: 规则。

WhenCandlesChanged``1

public static MarketRule<Subscription, TCandle> WhenCandlesChanged<TCandle>(ISubscriptionProvider subscriptionProvider, Subscription subscription)

result = MarketRuleHelper.WhenCandlesChanged(subscriptionProvider, subscription)

以创烛之变事之规.

subscriptionProvider: 订阅经理.
subscription: 蜡烛系列要追踪到改变后的蜡烛.

返回值: 规则。

WhenCandlesFinished

public static MarketRule<Subscription, ICandleMessage> WhenCandlesFinished(ISubscriptionProvider subscriptionProvider, Subscription subscription)

result = MarketRuleHelper.WhenCandlesFinished(subscriptionProvider, subscription)

以创烛会会事之规.

subscriptionProvider: 订阅经理.
subscription: 蜡烛系列要追踪蜡烛的结束.

返回值: 规则。

WhenCandlesFinished``1

public static MarketRule<Subscription, TCandle> WhenCandlesFinished<TCandle>(ISubscriptionProvider subscriptionProvider, Subscription subscription)

result = MarketRuleHelper.WhenCandlesFinished(subscriptionProvider, subscription)

以创烛会会事之规.

subscriptionProvider: 订阅经理.
subscription: 蜡烛系列要追踪蜡烛的结束.

返回值: 规则。

WhenCandlesStarted

public static MarketRule<Subscription, ICandleMessage> WhenCandlesStarted(ISubscriptionProvider subscriptionProvider, Subscription subscription)

result = MarketRuleHelper.WhenCandlesStarted(subscriptionProvider, subscription)

以创一出新烛所出事之规.

subscriptionProvider: 订阅经理.
subscription: 蜡烛系列要追踪到新的蜡烛.

返回值: 规则。

WhenCandlesStarted``1

public static MarketRule<Subscription, TCandle> WhenCandlesStarted<TCandle>(ISubscriptionProvider subscriptionProvider, Subscription subscription)

result = MarketRuleHelper.WhenCandlesStarted(subscriptionProvider, subscription)

以创一出新烛所出事之规.

subscriptionProvider: 订阅经理.
subscription: 蜡烛系列要追踪到新的蜡烛.

返回值: 规则。

WhenCandles``1

public static MarketRule<Subscription, TCandle> WhenCandles<TCandle>(ISubscriptionProvider subscriptionProvider, Subscription subscription)

result = MarketRuleHelper.WhenCandles(subscriptionProvider, subscription)

以创取出一出事之所由来之所由来之所由来之所由来之所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来所由来

subscriptionProvider: 订阅经理.
subscription: 蜡烛系列要追踪蜡烛.

返回值: 规则。

WhenChanged

public static MarketRule<Order, Order> WhenChanged(Order order, ISubscriptionProvider provider)

result = MarketRuleHelper.WhenChanged(order, provider)

创建更改顺序事件的规则。

order: 更改事件要追踪的顺序。
provider: 交易提供商.

返回值: 规则。

WhenChanged

public static MarketRule<Portfolio, Portfolio> WhenChanged(Portfolio portfolio, IPortfolioProvider provider)

result = MarketRuleHelper.WhenChanged(portfolio, provider)

创建一项规则,用于改变组合事件。

portfolio: 变化事件要追踪的项目组合.
provider: 提供组合信息。

返回值: 规则。

WhenChanged``1

public static MarketRule<TCandle, TCandle> WhenChanged<TCandle>(ISubscriptionProvider subscriptionProvider, TCandle candle)

result = MarketRuleHelper.WhenChanged(subscriptionProvider, candle)

以创烛之变事之规.

subscriptionProvider: 订阅经理.
candle: 蜡烛要追踪到变化

返回值: 规则。

WhenClosePriceLess``1

public static MarketRule<TCandle, TCandle> WhenClosePriceLess<TCandle>(ISubscriptionProvider subscriptionProvider, TCandle candle, Unit price)

result = MarketRuleHelper.WhenClosePriceLess(subscriptionProvider, candle, price)

制定"蜡烛收盘"降价低于特定水平事件规则.

subscriptionProvider: 订阅经理.
candle: 蜡烛的收尾价格降低到特定水平以下
price: 级别。如果类型等于绝对值, 则设定指定价格。否则, 指定了切换值。

返回值: 规则。

WhenClosePriceMore``1

public static MarketRule<TCandle, TCandle> WhenClosePriceMore<TCandle>(ISubscriptionProvider subscriptionProvider, TCandle candle, Unit price)

result = MarketRuleHelper.WhenClosePriceMore(subscriptionProvider, candle, price)

建立"烛收价超标事件"规则,超标到特定水平.

subscriptionProvider: 订阅经理.
candle: 蜡烛的追踪烛光关闭价格超标到特定水平
price: 级别。如果类型等于绝对值, 则设定指定价格。否则, 指定了切换值。

返回值: 规则。

WhenConnected

public static MarketRule<IConnector, IMessageAdapter> WhenConnected(IConnector connector)

result = MarketRuleHelper.WhenConnected(connector)

创建连接事件的规则。

connector: 州州要追踪的连接.

返回值: 规则。

WhenConnectionLost

public static MarketRule<IConnector, ValueTuple<IMessageAdapter, Exception>> WhenConnectionLost(IConnector connector)

result = MarketRuleHelper.WhenConnectionLost(connector)

为连接丢失的事件创建规则。

connector: 州州要追踪的连接.

返回值: 规则。

WhenDisconnected

public static MarketRule<IConnector, IMessageAdapter> WhenDisconnected(IConnector connector)

result = MarketRuleHelper.WhenDisconnected(connector)

创建一条规则,用于断开事件.

connector: 州州要追踪的连接.

返回值: 规则。

WhenEdited

public static MarketRule<Order, Order> WhenEdited(Order order, ITransactionProvider provider)

result = MarketRuleHelper.WhenEdited(order, provider)

为命令OrderEdited事件创建规则.

order: 须寻所取之序.
provider: 交易提供商.

返回值: 规则。

WhenEditFailed

public static MarketRule<Order, OrderFail> WhenEditFailed(Order order, ISubscriptionProvider provider)

result = MarketRuleHelper.WhenEditFailed(order, provider)

为命令OrderEditFailReceived事件创建规则.

order: 须寻所取之序.
provider: 交易提供商.

返回值: 规则。

WhenFinished``1

public static MarketRule<TCandle, TCandle> WhenFinished<TCandle>(ISubscriptionProvider subscriptionProvider, TCandle candle)

result = MarketRuleHelper.WhenFinished(subscriptionProvider, candle)

以创烛末事之规.

subscriptionProvider: 订阅经理.
candle: 将所追取之烛以入于末.

返回值: 规则。

WhenIntervalElapsed

public static MarketRule<ITimeProvider, ITimeProvider> WhenIntervalElapsed(ITimeProvider provider, TimeSpan interval)

result = MarketRuleHelper.WhenIntervalElapsed(provider, interval)

为事件CurrentTimeChanged创建规则,在. 到期后启动.

provider: ITimeProvider
interval: 相会相会.

返回值: 规则。

WhenLastTradePriceLess

public static MarketRule<Subscription, ITickTradeMessage> WhenLastTradePriceLess(Subscription subscription, ISubscriptionProvider provider, decimal level)

result = MarketRuleHelper.WhenLastTradePriceLess(subscription, provider, level)

制定将最后贸易价格降低到特定水平以下的事件发生的规则。

subscription: 订阅
provider: ISubscriptionProvider
level: 关上

返回值: 规则。

WhenLastTradePriceMore

public static MarketRule<Subscription, ITickTradeMessage> WhenLastTradePriceMore(Subscription subscription, ISubscriptionProvider provider, decimal level)

result = MarketRuleHelper.WhenLastTradePriceMore(subscription, provider, level)

制定上一个贸易价格高于具体水平的事件规则。

subscription: 订阅
provider: ISubscriptionProvider
level: 关上

返回值: 规则。

WhenLess

public static MarketRule<Position, Position> WhenLess(Position position, IPositionProvider provider, Unit value)

result = MarketRuleHelper.WhenLess(position, provider, value)

为职位低于特定级别的事件制定规则。

position: 低于具体水平的情况将予追踪。
provider: 位置提供商.
value: 级别。如果类型等于绝对值, 则设定指定价格。否则, 指定了切换值。

返回值: 规则。

WhenLevel1Received

public static MarketRule<Subscription, Level1ChangeMessage> WhenLevel1Received(Subscription subscription, ISubscriptionProvider provider)

result = MarketRuleHelper.WhenLevel1Received(subscription, provider)

为 LEVEIEDIEVE 事件创建规则。

subscription: 订阅.
provider: 订阅提供者.

返回值: 规则。

WhenMatched

public static MarketRule<Order, Order> WhenMatched(Order order, ISubscriptionProvider provider)

result = MarketRuleHelper.WhenMatched(order, provider)

要为命令完全匹配的事件创建规则。

order: 完全匹配事件要追踪的顺序。
provider: 交易提供商.

返回值: 规则。

WhenMoneyLess

public static MarketRule<Portfolio, Portfolio> WhenMoneyLess(Portfolio portfolio, IPortfolioProvider provider, Unit money)

result = MarketRuleHelper.WhenMoneyLess(portfolio, provider, money)

制定规则,处理低于具体水平的证券投资组合减少的情况。

portfolio: 资金数额低于具体数额的可追踪投资组合。
provider: 提供组合信息。
money: 级别。如果类型等于绝对值, 则设定指定价格。否则, 指定了切换值。

返回值: 规则。

WhenMoneyMore

public static MarketRule<Portfolio, Portfolio> WhenMoneyMore(Portfolio portfolio, IPortfolioProvider provider, Unit money)

result = MarketRuleHelper.WhenMoneyMore(portfolio, provider, money)

制定规定,处理超过具体水平的证券投资组合增加的问题。

portfolio: 资金增长超过具体水平的要追踪的投资组合。
provider: 提供组合信息。
money: 级别。如果类型等于绝对值, 则设定指定价格。否则, 指定了切换值。

返回值: 规则。

WhenMore

public static MarketRule<Position, Position> WhenMore(Position position, IPositionProvider provider, Unit value)

result = MarketRuleHelper.WhenMore(position, provider, value)

创建规则,用于职位增加超过特定级别的事件.

position: 超过具体水平的事件的发生情况。
provider: 位置提供商.
value: 级别。如果类型等于绝对值, 则设定指定价格。否则, 指定了切换值。

返回值: 规则。

WhenNewsReceived

public static MarketRule<Subscription, News> WhenNewsReceived(Subscription subscription, ISubscriptionProvider provider)

result = MarketRuleHelper.WhenNewsReceived(subscription, provider)

为 NewsReceived 事件创建规则。

subscription: 订阅.
provider: 订阅提供者.

返回值: 规则。

WhenNewTrade

public static MarketRule<Order, MyTrade> WhenNewTrade(Order order, ISubscriptionProvider provider)

result = MarketRuleHelper.WhenNewTrade(order, provider)

为订单设定贸易出事规则.

order: 交易事件要追查的顺序.
provider: 交易提供商.

返回值: 规则。

WhenOrderBookReceived

public static MarketRule<Subscription, IOrderBookMessage> WhenOrderBookReceived(Subscription subscription, ISubscriptionProvider provider)

result = MarketRuleHelper.WhenOrderBookReceived(subscription, provider)

为 OrderBookReceived 事件创建规则。

subscription: 订阅.
provider: 订阅提供者.

返回值: 规则。

WhenOrderEditFailReceived

public static MarketRule<Subscription, OrderFail> WhenOrderEditFailReceived(Subscription subscription, ISubscriptionProvider provider)

result = MarketRuleHelper.WhenOrderEditFailReceived(subscription, provider)

创建 OrderEditFailReceived 或 OrderCancelFailReceived 事件的规则。

subscription: 订阅.
provider: 订阅提供者.

返回值: 规则。

WhenOrderFailReceived

public static MarketRule<Subscription, OrderFail> WhenOrderFailReceived(Subscription subscription, ISubscriptionProvider provider, bool isRegister)

result = MarketRuleHelper.WhenOrderFailReceived(subscription, provider, isRegister)

创建 OrderRegisterFailReceived 或 OrderCancelFailReceived 事件的规则。

subscription: 订阅.
provider: 订阅提供者.
isRegister: OrderRegisterFailReceived或OrderCancelFailReceived.

返回值: 规则。

WhenOrderLogReceived

public static MarketRule<Subscription, IOrderLogMessage> WhenOrderLogReceived(Subscription subscription, ISubscriptionProvider provider)

result = MarketRuleHelper.WhenOrderLogReceived(subscription, provider)

为 OrderLogReceived 事件创建规则。

subscription: 订阅.
provider: 订阅提供者.

返回值: 规则。

WhenOrderReceived

public static MarketRule<Subscription, Order> WhenOrderReceived(ISubscriptionProvider provider)

result = MarketRuleHelper.WhenOrderReceived(provider)

为 OrderReceived 事件创建规则。

provider: 订阅提供者.

返回值: 规则。

WhenOrderReceived

public static MarketRule<Subscription, Order> WhenOrderReceived(Subscription subscription, ISubscriptionProvider provider)

result = MarketRuleHelper.WhenOrderReceived(subscription, provider)

为 OrderReceived 事件创建规则。

subscription: 订阅.
provider: 订阅提供者.

返回值: 规则。

WhenOrderRegistered

public static MarketRule<Subscription, Order> WhenOrderRegistered(Subscription subscription, ISubscriptionProvider provider)

result = MarketRuleHelper.WhenOrderRegistered(subscription, provider)

建立新秩序发生事件的规则。

subscription: 订阅.
provider: 订阅提供者.

返回值: 规则。

WhenOrderRegistered

public static MarketRule<Subscription, Order> WhenOrderRegistered(ISubscriptionProvider provider)

result = MarketRuleHelper.WhenOrderRegistered(provider)

建立新秩序发生事件的规则。

provider: 订阅提供者.

返回值: 规则。

WhenOwnTradeReceived

public static MarketRule<Subscription, MyTrade> WhenOwnTradeReceived(ISubscriptionProvider provider)

result = MarketRuleHelper.WhenOwnTradeReceived(provider)

为 OwnTradeReceived 事件创建规则。

provider: 订阅提供者.

返回值: 规则。

WhenOwnTradeReceived

public static MarketRule<Subscription, MyTrade> WhenOwnTradeReceived(Subscription subscription, ISubscriptionProvider provider)

result = MarketRuleHelper.WhenOwnTradeReceived(subscription, provider)

为 OwnTradeReceived 事件创建规则。

subscription: 订阅.
provider: 订阅提供者.

返回值: 规则。

WhenPartiallyFinishedCandles``1

public static MarketRule<Subscription, TCandle> WhenPartiallyFinishedCandles<TCandle>(ISubscriptionProvider subscriptionProvider, Subscription subscription, decimal percent)

result = MarketRuleHelper.WhenPartiallyFinishedCandles(subscriptionProvider, subscription, percent)

以建立烛花会场部分结束的规则.

subscriptionProvider: 订阅经理.
subscription: 蜡烛系列要追踪到蜡烛的部分端.
percent: 蜡烛完成的百分比。

返回值: 规则。

WhenPartiallyFinished``1

public static MarketRule<TCandle, TCandle> WhenPartiallyFinished<TCandle>(ISubscriptionProvider subscriptionProvider, TCandle candle, decimal percent)

result = MarketRuleHelper.WhenPartiallyFinished(subscriptionProvider, candle, percent)

以建立烛花会场部分结束的规则.

subscriptionProvider: 订阅经理.
candle: 蜡烛要追踪到部分终点.
percent: 蜡烛完成的百分比。

返回值: 规则。

WhenPartiallyMatched

public static MarketRule<Order, Order> WhenPartiallyMatched(Order order, ISubscriptionProvider provider)

result = MarketRuleHelper.WhenPartiallyMatched(order, provider)

为命令部分匹配事件创建规则。

order: 部分匹配事件要追踪的顺序。
provider: 交易提供商.

返回值: 规则。

WhenPortfolioReceived

public static MarketRule<Subscription, Portfolio> WhenPortfolioReceived(Subscription subscription, ISubscriptionProvider provider)

result = MarketRuleHelper.WhenPortfolioReceived(subscription, provider)

为 PortfolioReceived 事件创建规则。

subscription: 订阅.
provider: 订阅提供者.

返回值: 规则。

WhenPortfolioReceived

public static MarketRule<Subscription, Portfolio> WhenPortfolioReceived(ISubscriptionProvider provider)

result = MarketRuleHelper.WhenPortfolioReceived(provider)

为 PortfolioReceived 事件创建规则。

provider: 订阅提供者.

返回值: 规则。

WhenPositionReceived

public static MarketRule<Subscription, Position> WhenPositionReceived(Subscription subscription, ISubscriptionProvider provider)

result = MarketRuleHelper.WhenPositionReceived(subscription, provider)

为 PositionReceived 事件创建规则。

subscription: 订阅.
provider: 订阅提供者.

返回值: 规则。

WhenPositionReceived

public static MarketRule<Subscription, Position> WhenPositionReceived(ISubscriptionProvider provider)

result = MarketRuleHelper.WhenPositionReceived(provider)

为 PositionReceived 事件创建规则。

provider: 订阅提供者.

返回值: 规则。

WhenRegistered

public static MarketRule<Order, Order> WhenRegistered(Order order, ISubscriptionProvider provider)

result = MarketRuleHelper.WhenRegistered(order, provider)

为交换订单登记成功事件制定规则。

order: 成功登记事件应追查的顺序。
provider: 交易提供商.

返回值: 规则。

WhenRegisterFailed

public static MarketRule<Order, OrderFail> WhenRegisterFailed(Order order, ISubscriptionProvider provider)

result = MarketRuleHelper.WhenRegisterFailed(order, provider)

规定交换登记令失败的事件。

order: 登记活动未成功时的追查命令。
provider: 交易提供商.

返回值: 规则。

WhenSubscriptionFailed

public static MarketRule<Subscription, ValueTuple<Subscription, Exception, bool>> WhenSubscriptionFailed(Subscription subscription, ISubscriptionProvider provider)

result = MarketRuleHelper.WhenSubscriptionFailed(subscription, provider)

为 SubscriptionFailed 事件创建规则。

subscription: 订阅.
provider: 订阅提供者.

返回值: 规则。

WhenSubscriptionOnline

public static MarketRule<Subscription, Subscription> WhenSubscriptionOnline(Subscription subscription, ISubscriptionProvider provider)

result = MarketRuleHelper.WhenSubscriptionOnline(subscription, provider)

为 SubscriptionOnline 事件创建规则。

subscription: 订阅.
provider: 订阅提供者.

返回值: 规则。

WhenSubscriptionStarted

public static MarketRule<Subscription, Subscription> WhenSubscriptionStarted(Subscription subscription, ISubscriptionProvider provider)

result = MarketRuleHelper.WhenSubscriptionStarted(subscription, provider)

为 SubscriptionStarted 事件创建规则。

subscription: 订阅.
provider: 订阅提供者.

返回值: 规则。

WhenSubscriptionStopped

public static MarketRule<Subscription, ValueTuple<Subscription, Exception>> WhenSubscriptionStopped(Subscription subscription, ISubscriptionProvider provider)

result = MarketRuleHelper.WhenSubscriptionStopped(subscription, provider)

为 SubscriptionStopped 事件创建规则。

subscription: 订阅.
provider: 订阅提供者.

返回值: 规则。

WhenTargetReached

public static MarketRule<PositionTargetManager, ValueTuple<Security, Portfolio>> WhenTargetReached(PositionTargetManager manager, Security security, Portfolio portfolio)

result = MarketRuleHelper.WhenTargetReached(manager, security, portfolio)

创建规则, 目标位置到达时开火。

manager: 定位目标管理器。
security: 用于过滤的金融工具(任何工具的无效)。
portfolio: 要过滤的组合( 任意的无效) 。

返回值: 规则。

WhenTickTradeReceived

public static MarketRule<Subscription, ITickTradeMessage> WhenTickTradeReceived(Subscription subscription, ISubscriptionProvider provider)

result = MarketRuleHelper.WhenTickTradeReceived(subscription, provider)

为 TickTradeReceived 事件创建规则。

subscription: 订阅.
provider: 订阅提供者.

返回值: 规则。

WhenTimeCome

public static MarketRule<ITimeProvider, DateTime> WhenTimeCome(ITimeProvider provider, IEnumerable<DateTime> times)

result = MarketRuleHelper.WhenTimeCome(provider, times)

要创建规则,在准确的时间激活,通过 .

provider: ITimeProvider
times: 准确的时间。可能会发出若干个值。

返回值: 规则。

WhenTimeCome

public static MarketRule<ITimeProvider, DateTime> WhenTimeCome(ITimeProvider provider, DateTime[] times)

result = MarketRuleHelper.WhenTimeCome(provider, times)

要创建规则,在准确的时间激活,通过 .

provider: ITimeProvider
times: 准确的时间。可能会发出若干个值。

返回值: 规则。

WhenTotalVolumeMore``1

public static MarketRule<TCandle, TCandle> WhenTotalVolumeMore<TCandle>(ISubscriptionProvider subscriptionProvider, TCandle candle, Unit diff)

result = MarketRuleHelper.WhenTotalVolumeMore(subscriptionProvider, candle, diff)

建立关于烛花总体积超标特定水平事件的规则.

subscriptionProvider: 订阅经理.
candle: 蜡烛的出炉时间超过一定的温度
diff: 级别。如果类型等于绝对值, 则设定指定价格。否则, 指定了切换值。

返回值: 规则。