C# 的 SortedSet

表示一个按排序顺序维护的对象集合。

public class SortedSet < T > : System . Collections . Generic . ICollection < T > , System . Collections . Generic . IEnumerable < T > ,  System . Collections . Generic . IReadOnlyCollection < T > ,  System . Collections . Generic . IReadOnlySet < T > ,  System . Collections . Generic . ISet < T > ,  System . Collections . ICollection ,  System . Runtime . Serialization . IDeserializationCallback ,  System . Runtime . Serialization . ISerializable

参数

继承

实现

ICollection < T >，IEnumerable < T >，IReadOnlyCollection < T >，ISet < T >，ICollection，IEnumerable，IReadOnlySet < T >，IDeserializationCallback，ISerializable

示例

以下示例演示了一个 SortedSet < T > 类，该类通过接受 IComparer < T > 作为参数的构造函数创建。此比较器（ByFileExtension）用于按扩展名对文件名列表进行排序。

using System . Collections;

try
    {
    DirectoryInfo WJJ1 = new ( Environment . GetFolderPath ( Environment . SpecialFolder . MyDocuments ) );
    IEnumerable < FileInfo > WJs1 = WJJ1 . EnumerateFiles ( "*" , SearchOption . TopDirectoryOnly );
    SortedSet < FileInfo > WJs1图像 = new ( new LEI按文件扩展名 ( ) );
    foreach ( FileInfo wj in WJs1 )
        {
        Console . WriteLine ( wj . FullName );
        WJs1图像 . Add ( new FileInfo ( wj . FullName [ ( wj . FullName . LastIndexOf ( '\\' ) + 1 ) .. ] ) );
        }
    Console . WriteLine ( "在列表中移除文档……" );
    Console . WriteLine ( $"\t移除文档前……{WJs1图像 . Count}" );
    WJs1图像 . RemoveWhere ( FF是文档 );
    Console . WriteLine ( $"\t移除文档后……{WJs1图像 . Count}" );

    FileInfo? wj1 = null , wj2 = null;
    SortedSet < FileInfo > JPGs = WJs1图像 . GetViewBetween ( wj1 , wj2 );
    Console . WriteLine ( "图像文件：" );
    foreach ( FileInfo T in JPGs )
        {
        Console . WriteLine ( T . Name );
        }
    }
catch ( IOException ioEx )
    {
    Console . WriteLine ( ioEx . Message );
    }

catch ( UnauthorizedAccessException AuthEx )
    {
    Console . WriteLine ( AuthEx . Message );
    }


static bool FF是文档 ( FileInfo 文件 )
    {
    string 文件名 = 文件 . FullName . ToLower ( );
    return ( 文件名 . EndsWith ( ".txt" ) ||
            文件名 . EndsWith ( ".xls" ) ||
            文件名 . EndsWith ( ".xlsx" ) ||
            文件名 . EndsWith ( ".pdf" ) ||
            文件名 . EndsWith ( ".doc" ) ||
            文件名 . EndsWith ( ".docx" ) ) ||
            文件名 . EndsWith ( ".ini" ) ||
            文件名 . EndsWith ( ".dwg" ) ||
            文件名 . EndsWith ( ".accdb" );
    }

public class LEI按文件扩展名 : IComparer < FileInfo > , IComparer < string >
    {
    string? kz1 , kz2;
    private readonly CaseInsensitiveComparer BJQ不区分大小写 = new ( );

    public int Compare ( FileInfo? x , FileInfo? y )
        {
        if ( x == null || y == null ) return 0;
        kz1 = x . Extension;
        kz2 = y . Extension;

        // 比较两个文件的扩展名
        int z = BJQ不区分大小写 . Compare ( kz1 , kz2 );
        if ( z != 0 )
            {  return z; }
        else // 扩展名相同则比较文件名
            { return BJQ不区分大小写 . Compare ( x . Name , y . Name ); }
        }

    public int Compare ( string? x , string? y )
        {
        if ( x == null || y == null ) return 0;
        kz1 = x [ ( x . LastIndexOf ( '.' ) + 1 ) .. ];
        kz2 = y [ ( y . LastIndexOf ( '.' ) + 1 ) .. ];
        int z = BJQ不区分大小写 . Compare ( kz1 , kz2 );
        if ( z != 0 )
            { return z; }
        else
            { return BJQ不区分大小写 . Compare ( x , y ); }
        }
    }

备注

SortedSet < T > 对象可在插入和删除元素时维持排序顺序，且不会影响性能。不允许有重复元素。不支持更改现有项的排序值，这可能会导致意外行为。

关于集和集合

集可以用于描述 Collection，其内部可能是多种类型、没有顺序、可能重复的元素。而集合，即 Set，用于单类型、可以排序、可以去重的列表。

集可类比你逛大街，卖啥的都有，例如几家卖包子的；集合可类比你进了一家包子铺，商品琳琅满目，但都是包子，而且可能给你照食材、价格等因素排列好（SortedSet 会排序，HashSet 不会），但一定是一种包子一个食盘，挑着吃就是了。

构造函数

备注

此构造函数是一个 O（1）操作。

public SortedSet ( );
public SortedSet ( System . Collections . Generic . IComparer < T >? 比较器 );
public SortedSet ( System . Collections . Generic . IEnumerable < T > 集或集合 );
public SortedSet ( System . Collections . Generic . IEnumerable < T > 集或集合 , System . Collections . Generic . IComparer < T >? 比较器 );

参数

异常

示例

基础示例中，已经展示了使用 比较器 产生新的 SortedSet 的方式，下面的示例使用已存在的集合创建新的 SortedSet：

IEnumerable < int > ZHSs = [ 3 , 1 , 0 , -3 , 7 ];
SortedSet < int > ZHSs排序 = [ .. ZHSs ];
foreach ( int z in ZHSs排序 )
    {
    Console . Write ( $"{z}\t" );
    }

备注

当无需从 集或集合 中复制元素并排序，方法是个 O（1）操作；否则方法是个 O（n × log ( n )）操作，n 是 集或集合 中的元素数量。

被复制到 SortedSet 中的元素不会是重复的，即使 集 中有重复元素，且不会抛出异常。

属性

Comparer

获取用于对 SortedSet < T > 中的值进行排序的 IComparer < T > 对象。
public System . Collections . Generic . IComparer < T > Comparer { get; }

属性值

备注

返回的比较器可以是 SortedSet < T > 类型的默认比较器，也可以是其构造函数所使用的比较器。

检索此属性的值是一个 O（1）操作。

Count

获取 SortedSet < T > 中的元素的数量。
public Int Count { get; }

属性值

实现

Count ( )

备注

检索此属性的值是一个 O（1）操作。

Max 和 Min

获取由比较器定义的 SortedSet < T > 中的最大值或最小值。

public T? Max { get; }
public T? Min { get; }

属性值

备注

如果 SortedSet < T > 不包含任何元素，则 Max 或 Min 属性会返回 T 的默认值。

方法

Add 和 Remove

向集合添加或删除一个元素，并返回一个值，该值指示是否成功添加或删除了该元素。

public bool Add ( T 项目 );
public bool Remove ( T 项目 );

返回值

示例

IEnumerable < int > ZHSs = [ 3 , 1 , 0 , -3 , 3 , 7 ];
SortedSet < int > ZHSs排序 = [ .. ZHSs ];
foreach ( int z in ZHSs排序 )
    {
    Console . Write ( $"{z}\t" );
    }
Console . WriteLine ( );

ZHSs排序 . Add ( 9 );
ZHSs排序 . Remove ( 7 );
ZHSs排序 . Add ( 3 );
ZHSs排序 . Remove ( -1 );

foreach ( int z in ZHSs排序 )
    Console . Write ( $"{z}\t" );

备注

SortedSet < T > 类不接受重复元素。如果 项目 已在集合中，Add 方法会返回 false 且不会抛出异常。

如果计数已等于 SortedSet < T > 对象的容量，则会自动调整容量以容纳新项。

如果 SortedSet < T > 对象不包含指定元素，则移除该对象的元素该对象保持不变，且不会抛出异常。

对于引用类型，项目 可以为 null。

Remove 方法是一个 O（log ( n)）操作。

Clear

在 SortedSet 中移除所有元素。
public virtual void Clear ( );

实现

Clear ( )

备注

此方法是一个 O（n）操作，其中 n 为 SortedSet . Count。

Contains

确定 SrotedSet 中是否包含特定元素。
public virtual bool Contains ( T 项目 );

参数

返回值

实现

Contains ( )

备注

此方法是一个 O（log ( n )）操作。

CopyTo

将 SortedSet < T > 的一部分或全部复制到兼容的一维数组中，从目标数组的开头或指定索引处开始。

重载

public void CopyTo ( T [ ] 数组 );
public void CopyTo ( T [ ] 数组 , int 起始索引 );
public void CopyTo ( T [ ] 数组 , int 起始索引 , int 元素数 );

参数

实现

CopyTo ( T [ ] , Int32 )

异常

备注

数组 必须是一维的，以 0 为起始索引的，且能容纳 SortedSet 元素类型的数组。

复制一定是自 SortedSet 启始元素开始，复制整个 SortedSet 或指定 元素数 为止。起始索引 只和目标数组有关。因为 SortedSet 没有索引器。

此方法是一个 O（n）操作，其中 n 为 SortedSet 的 Count 或指定 元素数。

CreateSetComparer

返回一个 IEqualityComparer 对象，该对象可用于创建包含各个 SortedSet 的集合。

重载

public static System . Collections . Generic . IEqualityComparer < System . Collections . Generic . SortedSet < T > > CreateSetComparer ( );
public static System . Collections . Generic . IEqualityComparer < System . Collections . Generic . SortedSet < T > > CreateSetComparer ( System . Collections . Generic . IEqualityComparer < T >? 成员相等比较器 );

参数

返回值

示例

以下示例创建了一个 比较器（来自 SortedSet < double >），并用其创建一个存储两个 double 的 SortedSet 的 HashSet：

IEnumerable < double > ZHSs = [ 3 , 1 , 0 , -3 , 3 , 7 ];
IEnumerable < double > SJDs = [ 6.5 , 21.3 , -10 , -30.6 , 13.8 , 17.6 , 13.8 ];
SortedSet < double > ZHSs排序 = [ .. ZHSs ];
SortedSet < double > SJDs排序 = [ .. SJDs ];
IEqualityComparer < SortedSet < double > > bjq = SortedSet < double > . CreateSetComparer ( );
Console . WriteLine ( bjq . ToString ( ) );

HashSet < SortedSet < double > > JH = new ( bjq )
    {
    ZHSs排序,
    SJDs排序
    };
foreach ( var z in JH )
    {
    foreach ( var x in z )
        { Console . Write ( $"{x}\t" ); }
    Console . WriteLine ( );
    }

备注

IEqualityComparer 对象仅在一个级别检查相等性；但是，您可以在其他级别将比较器链接在一起，以执行更深入的相等性测试。

调用此方法是一个 O（1）操作。

成员相等比较器 和当前的 SortedSet < T > 必须具有相同的相等性定义；其为 null 则与不带参数的 CreateSetComparer 一个效果。

你可以在 SortedSet < T > . SortedSet < T > ( IEnumerable < T > , IComparer < T > ) 构造函数中使用此方法返回的比较器来创建各个集合的哈希表。

ExceptWith

从当前的 SortedSet < T > 对象中移除所有存在于指定集或集合中的元素（差集）。
public void ExceptWith ( System . Collections . Generic . IEnumerable < T > 另一个 );

参数

实现

ExceptWith ( IEnumerable < T > )

异常

示例

IEnumerable < double > ZHSs = [ 3 , 1 , 0 , -3 , 3 , 7 ];
IEnumerable < double > SJDs = [ 6.5 , 21.3 , -10 , -30.6 , 13.8 , 17.6 , 13.8 , 1 , 3 , 3 ];
SortedSet < double > ZHSs排序 = [ .. ZHSs ];
SortedSet < double > SJDs排序 = [ .. SJDs ];

ZHSs排序 . ExceptWith ( SJDs排序 );
foreach ( var z in ZHSs排序 )
    { Console . WriteLine ( z ); }

备注

此方法会移除当前 SortedSet < T > 中同时存在于 另一个 中的任何元素。另一个（如果是集）中的重复值会被忽略。

该方法等同于数学上的 A - B。

此方法是一个 O（n × log ( m )）操作，其中 m 为 SortedSet . Count，n 为 另一个 . Count。

GetViewBetween

返回 SortedSet < T > 中子集的视图。
public virtual System . Collections . Generic . SortedSet < T > GetViewBetween ( T? 低值 , T? 高值 );

参数

返回值

异常

示例

以下示例描述了一个 Double SortedSet，并选择其中 0 到 7 范围内生成新的视图，且尝试引发 ArgumentOutOfRangeException：

IEnumerable < double > SJDs = [ 6.5 , 21.3 , -10 , -30.6 , 13.8 , 17.6 , 13.8 , 1 , 3 , 3 ];
SortedSet < double > SJDs排序 = [ .. SJDs ];

SortedSet < double > SJDs07 = SJDs排序 . GetViewBetween ( 0 , 7 ); // 生成以 SJDs排序 为基础的，包含其中 0 到 7 范围内的数值的视图
foreach ( var z in SJDs07 )
    { Console . WriteLine ( z ); }
try
    {
    SJDs07 . Add ( 8 ); // SJDs07 限制其值包括 0 到 7 范围内的 Double，所以向其添加 8 异常
    }
catch ( Exception yc ) { Console . WriteLine ( yc . Message ); } // ArgumentOutOfRangeException

备注

此方法返回由比较器定义的、落在 低值 和 高值 之间的元素范围的视图。此方法不会从 SortedSet < T > 中复制元素，而是提供对基于 SortedSet < T > 本身的窗口。您可以在视图和基础 SortedSet < T > 中进行更改。例如例程中可以向视图 SJDs07 添加 5.5，SJDs排序 也添加了 5.5；也可以向 SJDs排序 添加 5.5，SJDs07 也添加了 5.5；但 SJDs07 的任意操作都被限制只能在 0 到 7 之间。

低值 和 高值 都可以是 null。低值 为 null，视图中包含所有小于 高值 的元素；高值 为 null，视图中包含所有大于 低值 的元素；均为 null，视图中包含所有 SortedSet 的元素。

IntersectWith

修改当前的 SortedSet < T > 对象，使其仅包含也存在于指定集或集合中的元素。
public virtual void IntersectWith ( System . Collections . Generic . IEnumerable < T > 另一个 );

参数

实现

IntersectWith ( IEnumerable < T > )

异常

示例

以下示例使用一个 集 修改 SortedSet 实例，获取其交集：

IEnumerable < double > SJDs = [ 6.5 , 21.3 , -10 , -30.6 , 13.8 , 17.6 , 13.8 , 1 , 3 , 3 ];
SortedSet < double > SJDs排序 = [ .. SJDs ];
IEnumerable < double > SJDs1 = [ 6.5 , 21.3 , 13 , 15 ];

SJDs排序 . IntersectWith ( SJDs1 );
foreach ( var z in SJDs排序 )
    { Console . Write ( $"{z}\t" ); }

备注

此方法忽略 另一个（若是集）中的任何重复元素。

执行 IntersectWith 方法后的 SortedSet 对象仅包含原 SortedSet 实例与 另一个 共同拥有的元素。等同于数学概念中的 A ∩ B。此时的 A 可能没有元素，因为 A ∩ B = ∅（没有共同元素）。

如果 交集 参数所表示的集合是与当前 SortedSet < T > 对象具有相同相等比较器的 SortedSet < T > 集合，则此方法是一个 O（n） 操作。否则，此方法是一个 O（n + m）操作，其中 n 为原 SortedSet . Count，m 为 交集 . Count。

IsProperSubsetOf、IsProperSupersetOf、IsSubsetOf 和 IsSupersetOf

描述某个集或集合是否是当前实例的真子集、真超集、子集和超集。

public bool IsProperSubsetOf ( System . Collections . Generic . IEnumerable < T > 真子集 );
public bool IsProperSupersetOf ( System . Collections . Generic . IEnumerable < T > 真超集 );
public bool IsSubsetOf ( System . Collections . Generic . IEnumerable < T > 子集 );
public bool IsSupersetOf ( System . Collections . Generic . IEnumerable < T > 超集 );

参数

返回值

实现

IsProperSubsetOf ( IEnumerable < T > )
IsProperSupersetOf ( IEnumerable < T > )
IsSubsetOf ( IEnumerable < T > )
IsSupersetOf ( IEnumerable < T > )

异常

备注

若 SortedSet A = [ 1 , 2 , 3 , 4 , 5 ]，B = [ 1 , 2 ]，则
A 是 B 的真超集，记作 A ⊃ B；B 是 A 的真子集，记作 B ⊂ A（同时也分别是超集（⊇）和子集（⊆））。

超集即包含该 SortedSet 实例的所有元素的集合，真超集则还包含其他元素；子集即包含该 SortedSet 实例的全部或部分元素的集合，真子集仅包含部分元素。

空的 SortedSet 是任意集或集合的子集，是任意有元素的集或集合的真子集；任意集或集合是空的 SortedSet 的超集，有元素的集或集合是空的 SortedSet 的真超集。

如下表，这些方法将始终返回 false。

如果由 参数 表示的集或集合是与当前 SortedSet < T > 对象具有相同相等比较器的 SortedSet < T > 集合，则此方法是一个 O（n）操作。否则，此方法是一个 O（n + m）操作，其中 n 是 SortedSet . Count，m 是 参数 . Count。

Overlaps

确定当前的 SortedSet < T > 对象和指定的集或集合是否包含共同元素。
public bool Overlaps ( System . Collections . Generic . IEnumerable < T > 另一个 );

参数

返回值

实现

Overlaps ( IEnumerable < T > )

异常

备注

另一个（若是集）中的任何重复元素将被忽略。

该方法数学含义可表示为 A ∩ B ≠ ∅。即两集合或集有交集（有公共元素）。

此方法是一个 O（n × log ( m )）操作，其中 m 为 SortedSet . Count，n 为 另一个 . Count。最简单的情况是 SortedSet 实例或/和 另一个 是空集，O（1）操作，直接返回 false；否则，n 可能是大于等于 1 并小于等于 另一个 . Count 的任意值，直到找到共有元素为止，最坏的情况是检索到 另一个 的最后一个元素。

RemoveWhere

从 SortedSet < T > 中移除所有与指定谓词定义的条件相匹配的元素。
public int RemoveWhere ( Predicate < T > 匹配 );

参数

返回值

异常

示例

以下示例创建一个 20 个元素的 int SortedSet，并从中移除 2 的倍数和 3 的倍数，但不移除即是 2 的倍数又是 3 的倍数（即 6 的倍数）：

SortedSet < int > ZHSs排序 = [ ];
for ( int z = 0 ; z <= 19 ; z++ )
    ZHSs排序 . Add ( z );
int zhs项目 = ZHSs排序 . RemoveWhere ( FF2Or3B );
Console . WriteLine ( $"共移除了 {zhs项目} 项。" );
foreach ( var z in ZHSs排序 ) Console . WriteLine ( z );

static bool FF2Or3B ( int 整数 )
    {
    bool ber2he3B = 整数 % ( 2 * 3 ) == 0;
    bool ber2huo3B = 整数 % 2 == 0 || 整数 % 3 == 0;
    // 仅当 整数 是 2 的倍数且不是 3 的倍数；或者是 3 的倍数且不是 2 的倍数，返回 true
    return ber2huo3B && !ber2he3B;
    }

备注

匹配 不得修改 SortedSet < T >。这样做可能会导致意外结果。

调用此方法是一个 O（n）操作，其中 n 为 SortedSet . Count。

Reverse

返回一个 IEnumerable < T >，它按相反顺序循环访问 SortedSet < T >。
public System . Collections . Generic . IEnumerable < T > Reverse ( );

返回值

示例

以下示例创建了一个 10 个元素的 SortedSet，并将其反转：

SortedSet < int > ZHSs排序 = [ ];
for ( int z = 0 ; z <= 9 ; z++ )
    ZHSs排序 . Add ( z );

Console . WriteLine ( "倒序前：" );
foreach ( var z in ZHSs排序 )
    { Console . Write ( $"{z}\t" ); }
Console . WriteLine ( );

IEnumerable < int > ZHSs倒序 = ZHSs排序 . Reverse ( );
Console . WriteLine ( "倒序后：" );
foreach ( var z in ZHSs倒序 )
    { Console . Write ( $"{z}\t" ); }
Console . WriteLine ( );

// 以下代码依然使用上述代码，但在输出 ZHSs倒序 之前，向 ZHSs排序 添加了一个元素 20
Console . WriteLine ( "倒序前：" );
foreach ( var z in ZHSs排序 )
    { Console . Write ( $"{z}\t" ); }
Console . WriteLine ( );

ZHSs排序 . Add ( 20 );
Console . WriteLine ( "倒序后：" );
foreach ( var z in ZHSs倒序 )
    { Console . Write ( $"{z}\t" ); }
Console . WriteLine ( );

备注

返回值 是 SortedSet 实例的一个镜本（不是副本，不可修改），对 SortedSet 实例的修改（离开镜子，延迟读取）会在执行 Reverse 时立刻反映在返回值中（再次照镜子）。

SetEquals

确定当前的 SortedSet < T > 对象和指定的集或集合是否包含相同的元素。
public bool SetEquals ( System . Collections . Generic . IEnumerable < T > 另一个 );

参数

返回值

实现

SetEquals ( IENumable < T > )

异常

示例

以下示例创建三个 SortedSet 或实现 IEnumerable 接口的对象，与 SortedSet 实例进行比较：

IEnumerable < int > ZHSs整数 = [ 3 , 1 , 2 ];
SortedSet < int > ZHSs排序 = [ .. ZHSs整数 ];
IEnumerable < int > BJMB2 = [ 3 , 1 , 1 , 2 ];
IEnumerable < int > BJMB3 = BJMB2 . Append ( 4 );

object [ ] BJMB =
    [
    new SortedSet < int > ( [ .. ZHSs整数 ] ),
    BJMB2,
    BJMB3,
    ];

foreach ( var bj in BJMB )
    Console . WriteLine ( $"ZHSs排序 . SetEquals ( {string . Join ( "，" , ( IEnumerable < int > ) bj )} ) = {ZHSs排序 . SetEquals ( ( IEnumerable < int > ) bj )}" );

备注

此方法忽略 另一个 中元素的顺序和任何重复元素。

如果由 另一个 表示的集合是与当前 SortedSet < T > 对象具有相同相等比较器的 SortedSet < T > 集合，则此方法是一个 O（log ( n )）操作。否则，此方法是一个O（n + m）操作，其中 n 是 另一个 . Count，m 是 SortedSet . Count。

SymmetricExceptWith

修改当前的 SortedSet < T > 对象，使其仅包含存在于当前对象中或指定集合中，但不同时存在于两者中的元素（即对称差集）。
public void SymmetricExceptWith ( System . Collections . Generic . IEnumerable < T > 另一个 );

参数

实现

SymmetricExceptWith ( IEnumerable < T > )

异常

备注

另一个 中的任何重复元素都会被忽略。

A . SymmetricExceptWith ( B ) 之后，A 将保留属于 A 但不属于 B 的元素，移除既属于 A 且属于 B 的元素，添加属于 B 但不属于 A 的元素。即数学上的 A △ B，或 (A - B) ∪ (B - A)。

如果 另一个 参数是与当前 SortedSet < T > 对象具有相同相等比较器的 SortedSet < T > 集合，则此方法是一个 O（n × log ( m )）操作。否则，此方法是一个 O（n × log ( m )） + O（n × log ( n )）操作，其中 n 是 另一个 . Count，m 是 SortedSet . Count。

TryGetValue

在集合中搜索给定值，如果找到相等的值，则输出该值。
public bool TryGetValue ( T 搜索值 , out T 输出值 );

参数

返回值

备注

当您的 SortedSet 是引用类型（string、class 等），想要重复使用以前存储的引用而不是新构建的引用（以便可以发生更多引用共享）或查找比当前值具有更完整数据的值时，这可能很有用，尽管它们的比较器函数表明它们是相等的。但对于值类型（int、struct 等），输出值 是 搜索到的值 的副本（或者默认值），只能表示该值是否存在于 SortedSet 中，倒不如使用 Contains 方法。

当 搜索值 即为 T 类型的默认值，例如在 int SortedSet 中搜索 0，返回值为 true，输出值是 0，表示搜索到 0；否则，没有搜索到该值，但输出值依然是 0。无论搜索什么值，不要以 输出值 的内容判断该值是否存在，必须由该方法的返回值确定。

UnionWith

修改当前的 SortedSet < T > 对象，使其包含当前对象和指定集或集合中存在的所有元素。
public void UnionWith ( System . Collections . Generic . IEnumerable < T > 另一个);

参数

实现

UnionWith ( IEnumerable < T > )

异常

备注

另一个（如果是集）中的任何重复元素都会被忽略。该方法即数学中的并集（A ∪ B）。