前言

这一次要和大家分享的一个Tips是在字符串拼接场景使用的，我们经常会遇到有很多短小的字符串需要拼接的场景，在这种场景下及其的不推荐使用String.Concat也就是使用+=运算符。

目前来说官方最推荐的方案就是使用StringBuilder来构建这些字符串，那么有什么更快内存占用更低的方式吗？那就是今天要和大家介绍的ValueStringBuilder。

ValueStringBuilder

ValueStringBuilder不是一个公开的API，但是它被大量用于.NET的基础类库中，由于它是值类型的，所以它本身不会在堆上分配，不会有GC的压力。

微软提供的ValueStringBuilder有两种使用方式，一种是自己已经有了一块内存空间可供字符串构建使用。这意味着你可以使用栈空间，也可以使用堆空间甚至非托管堆的空间，这对于GC来说是非常友好的，在高并发情况下能大大降低GC压力。

  1. // 构造函数：传入一个Span的Buffer数组
  2. public ValueStringBuilder(Span<char> initialBuffer);
  4. // 使用方式：
  5. // 栈空间
  6. var vsb = new ValueStringBuilder(stackalloc char[512]);
  7. // 普通数租
  8. var vsb = new ValueStringBuilder(new char[512]);
  9. // 使用非托管堆
  10. var length = 512;
  11. var ptr = NativeMemory.Alloc((nuint)(512 * Unsafe.SizeOf<char>()));
  12. var span = new Span<char>(ptr, length);
  13. var vsb = new ValueStringBuilder(span);
  14. .....
  15. NativeMemory.Free(ptr); // 非托管堆用完一定要Free

另外一种方式是指定一个容量，它会从默认的ArrayPool的char对象池中获取缓冲空间，因为使用的是对象池，所以对于GC来说也是比较友好的，千万需要注意，池中的对象一定要记得归还。

  1. // 传入预计的容量
  2. public ValueStringBuilder(int initialCapacity)
  3. {
  4.     // 从对象池中获取缓冲区
  5.     _arrayToReturnToPool = ArrayPool<char>.Shared.Rent(initialCapacity);
  6.     ......
  7. }

那么我们就来比较一下使用+=、StringBuilder和ValueStringBuilder这几种方式的性能吧。

  1. // 一个简单的类
  2. public class SomeClass
  3. {
  4.     public int Value1; public int Value2; public float Value3;
  5.     public double Value4; public string? Value5; public decimal Value6;
  6.     public DateTime Value7; public TimeOnly Value8; public DateOnly Value9;
  7.     public int[]? Value10;
  8. }
  9. // Benchmark类
  10. [MemoryDiagnoser]
  11. [HtmlExporter]
  12. [Orderer(SummaryOrderPolicy.FastestToSlowest)]
  13. public class StringBuilderBenchmark
  14. {
  15.     private static readonly SomeClass Data;
  16.     static StringBuilderBenchmark()
  17.     {
  18.         var baseTime = DateTime.Now;
  19.         Data = new SomeClass
  20.         {
  21.             Value1 = 100, Value2 = 200, Value3 = 333,
  22.             Value4 = 400, Value5 = string.Join('-', Enumerable.Range(0, 10000).Select(i => i.ToString())),
  23.             Value6 = 655, Value7 = baseTime.AddHours(12),
  24.             Value8 = TimeOnly.MinValue, Value9 = DateOnly.MaxValue,
  25.             Value10 = Enumerable.Range(0, 5).ToArray()
  26.         };
  27.     }
  29.     // 使用我们熟悉的StringBuilder
  30.     [Benchmark(Baseline = true)]
  31.     public string StringBuilder()
  32.     {
  33.         var data = Data;
  34.         var sb = new StringBuilder();
  35.         sb.Append("Value1:"); sb.Append(data.Value1);
  36.         if (data.Value2 > 10)
  37.         {
  38.             sb.Append(" ,Value2:"); sb.Append(data.Value2);
  39.         }
  40.         sb.Append(" ,Value3:"); sb.Append(data.Value3);
  41.         sb.Append(" ,Value4:"); sb.Append(data.Value4);
  42.         sb.Append(" ,Value5:"); sb.Append(data.Value5);
  43.         if (data.Value6 > 20)
  44.         {
  45.             sb.Append(" ,Value6:"); sb.AppendFormat("{0:F2}", data.Value6);
  46.         }
  47.         sb.Append(" ,Value7:"); sb.AppendFormat("{0:yyyy-MM-dd HH:mm:ss}", data.Value7);
  48.         sb.Append(" ,Value8:"); sb.AppendFormat("{0:HH:mm:ss}", data.Value8);
  49.         sb.Append(" ,Value9:"); sb.AppendFormat("{0:yyyy-MM-dd}", data.Value9);
  50.         sb.Append(" ,Value10:");
  51.         if (data.Value10 is null or {Length: 0}) return sb.ToString();
  52.         for (int i = 0; i < data.Value10.Length; i++)
  53.         {
  54.             sb.Append(data.Value10[i]);
  55.         }  
  57.         return sb.ToString();
  58.     }
  60.     // StringBuilder使用Capacity
  61.     [Benchmark]
  62.     public string StringBuilderCapacity()
  63.     {
  64.         var data = Data;
  65.         var sb = new StringBuilder(20480);
  66.         sb.Append("Value1:"); sb.Append(data.Value1);
  67.         if (data.Value2 > 10)
  68.         {
  69.             sb.Append(" ,Value2:"); sb.Append(data.Value2);
  70.         }
  71.         sb.Append(" ,Value3:"); sb.Append(data.Value3);
  72.         sb.Append(" ,Value4:"); sb.Append(data.Value4);
  73.         sb.Append(" ,Value5:"); sb.Append(data.Value5);
  74.         if (data.Value6 > 20)
  75.         {
  76.             sb.Append(" ,Value6:"); sb.AppendFormat("{0:F2}", data.Value6);
  77.         }
  78.         sb.Append(" ,Value7:"); sb.AppendFormat("{0:yyyy-MM-dd HH:mm:ss}", data.Value7);
  79.         sb.Append(" ,Value8:"); sb.AppendFormat("{0:HH:mm:ss}", data.Value8);
  80.         sb.Append(" ,Value9:"); sb.AppendFormat("{0:yyyy-MM-dd}", data.Value9);
  81.         sb.Append(" ,Value10:");
  82.         if (data.Value10 is null or {Length: 0}) return sb.ToString();
  83.         for (int i = 0; i < data.Value10.Length; i++)
  84.         {
  85.             sb.Append(data.Value10[i]);
  86.         }  
  88.         return sb.ToString();
  89.     }  
  91.     // 直接使用+=拼接字符串
  92.     [Benchmark]
  93.     public string StringConcat()
  94.     {
  95.         var str = "";
  96.         var data = Data;
  97.         str += ("Value1:"); str += (data.Value1);
  98.         if (data.Value2 > 10)
  99.         {
  100.             str += " ,Value2:"; str += data.Value2;
  101.         }
  102.         str += " ,Value3:"; str += (data.Value3);
  103.         str += " ,Value4:"; str += (data.Value4);
  104.         str += " ,Value5:"; str += (data.Value5);
  105.         if (data.Value6 > 20)
  106.         {
  107.             str += " ,Value6:"; str += data.Value6.ToString("F2");
  108.         }
  109.         str += " ,Value7:"; str += data.Value7.ToString("yyyy-MM-dd HH:mm:ss");
  110.         str += " ,Value8:"; str += data.Value8.ToString("HH:mm:ss");
  111.         str += " ,Value9:"; str += data.Value9.ToString("yyyy-MM-dd");
  112.         str += " ,Value10:";
  113.         if (data.Value10 is not null && data.Value10.Length > 0)
  114.         {
  115.             for (int i = 0; i < data.Value10.Length; i++)
  116.             {
  117.                 str += (data.Value10[i]);
  118.             }
  119.         }  
  121.         return str;
  122.     }  
  124.     // 使用栈上分配的ValueStringBuilder
  125.     [Benchmark]
  126.     public string ValueStringBuilderOnStack()
  127.     {
  128.         var data = Data;
  129.         Span<char> buffer = stackalloc char[20480];
  130.         var sb = new ValueStringBuilder(buffer);
  131.         sb.Append("Value1:"); sb.AppendSpanFormattable(data.Value1);
  132.         if (data.Value2 > 10)
  133.         {
  134.             sb.Append(" ,Value2:"); sb.AppendSpanFormattable(data.Value2);
  135.         }
  136.         sb.Append(" ,Value3:"); sb.AppendSpanFormattable(data.Value3);
  137.         sb.Append(" ,Value4:"); sb.AppendSpanFormattable(data.Value4);
  138.         sb.Append(" ,Value5:"); sb.Append(data.Value5);
  139.         if (data.Value6 > 20)
  140.         {
  141.             sb.Append(" ,Value6:"); sb.AppendSpanFormattable(data.Value6, "F2");
  142.         }
  143.         sb.Append(" ,Value7:"); sb.AppendSpanFormattable(data.Value7, "yyyy-MM-dd HH:mm:ss");
  144.         sb.Append(" ,Value8:"); sb.AppendSpanFormattable(data.Value8, "HH:mm:ss");
  145.         sb.Append(" ,Value9:"); sb.AppendSpanFormattable(data.Value9, "yyyy-MM-dd");
  146.         sb.Append(" ,Value10:");
  147.         if (data.Value10 is not null && data.Value10.Length > 0)
  148.         {
  149.             for (int i = 0; i < data.Value10.Length; i++)
  150.             {
  151.                 sb.AppendSpanFormattable(data.Value10[i]);
  152.             }
  153.         }  
  155.         return sb.ToString();
  156.     }
  157.     // 使用ArrayPool 堆上分配的StringBuilder
  158.     [Benchmark]
  159.     public string ValueStringBuilderOnHeap()
  160.     {
  161.         var data = Data;
  162.         var sb = new ValueStringBuilder(20480);
  163.         sb.Append("Value1:"); sb.AppendSpanFormattable(data.Value1);
  164.         if (data.Value2 > 10)
  165.         {
  166.             sb.Append(" ,Value2:"); sb.AppendSpanFormattable(data.Value2);
  167.         }
  168.         sb.Append(" ,Value3:"); sb.AppendSpanFormattable(data.Value3);
  169.         sb.Append(" ,Value4:"); sb.AppendSpanFormattable(data.Value4);
  170.         sb.Append(" ,Value5:"); sb.Append(data.Value5);
  171.         if (data.Value6 > 20)
  172.         {
  173.             sb.Append(" ,Value6:"); sb.AppendSpanFormattable(data.Value6, "F2");
  174.         }
  175.         sb.Append(" ,Value7:"); sb.AppendSpanFormattable(data.Value7, "yyyy-MM-dd HH:mm:ss");
  176.         sb.Append(" ,Value8:"); sb.AppendSpanFormattable(data.Value8, "HH:mm:ss");
  177.         sb.Append(" ,Value9:"); sb.AppendSpanFormattable(data.Value9, "yyyy-MM-dd");
  178.         sb.Append(" ,Value10:");
  179.         if (data.Value10 is not null && data.Value10.Length > 0)
  180.         {
  181.             for (int i = 0; i < data.Value10.Length; i++)
  182.             {
  183.                 sb.AppendSpanFormattable(data.Value10[i]);
  184.             }
  185.         }
  187.         return sb.ToString();
  188.     }
  190. }

结果如下所示。



从上图的结果中，我们可以得出如下的结论。

  • 使用StringConcat是最慢的，这种方式是无论如何都不推荐的。
  • 使用StringBuilder要比使用StringConcat快6.5倍，这是推荐的方法。
  • 设置了初始容量的StringBuilder要比直接使用StringBuilder快25%，正如我在你应该为集合类型设置初始大小一样，设置初始大小绝对是相当推荐的做法。
  • 栈上分配的ValueStringBuilder比StringBuilder要快50%，比设置了初始容量的StringBuilder还快25%，另外它的GC次数是最低的。
  • 堆上分配的ValueStringBuilder比StringBuilder要快55%，他的GC次数稍高与栈上分配。

    从上面的结论中，我们可以发现ValueStringBuilder的性能非常好，就算是在栈上分配缓冲区，性能也比StringBuilder快25%。

源码解析

ValueStringBuilder的源码不长，我们挑几个重要的方法给大家分享一下，部分源码如下。

  1. // 使用 ref struct 该对象只能在栈上分配
  2. public ref struct ValueStringBuilder
  3. {
  4.     // 如果从ArrayPool里分配buffer 那么需要存储一下
  5.     // 以便在Dispose时归还
  6.     private char[]? _arrayToReturnToPool;
  7.     // 暂存外部传入的buffer
  8.     private Span<char> _chars;
  9.     // 当前字符串长度
  10.     private int _pos;
  12.     // 外部传入buffer
  13.     public ValueStringBuilder(Span<char> initialBuffer)
  14.     {
  15.         // 使用外部传入的buffer就不使用从pool里面读取的了
  16.         _arrayToReturnToPool = null;
  17.         _chars = initialBuffer;
  18.         _pos = 0;
  19.     }
  21.     public ValueStringBuilder(int initialCapacity)
  22.     {
  23.         // 如果外部传入了capacity 那么从ArrayPool里面获取
  24.         _arrayToReturnToPool = ArrayPool<char>.Shared.Rent(initialCapacity);
  25.         _chars = _arrayToReturnToPool;
  26.         _pos = 0;
  27.     }
  29.     // 返回字符串的Length 由于Length可读可写
  30.     // 所以重复使用ValueStringBuilder只需将Length设置为0
  31.     public int Length
  32.     {
  33.         get => _pos;
  34.         set
  35.         {
  36.             Debug.Assert(value >= 0);
  37.             Debug.Assert(value <= _chars.Length);
  38.             _pos = value;
  39.         }
  40.     }
  42.     ......
  44.     [MethodImpl(MethodImplOptions.AggressiveInlining)]
  45.     public void Append(char c)
  46.     {
  47.         // 添加字符非常高效 直接设置到对应Span位置即可
  48.         int pos = _pos;
  49.         if ((uint) pos < (uint) _chars.Length)
  50.         {
  51.             _chars[pos] = c;
  52.             _pos = pos + 1;
  53.         }
  54.         else
  55.         {
  56.             // 如果buffer空间不足，那么会走
  57.             GrowAndAppend(c);
  58.         }
  59.     }
  61.     [MethodImpl(MethodImplOptions.AggressiveInlining)]
  62.     public void Append(string? s)
  63.     {
  64.         if (s == null)
  65.         {
  66.             return;
  67.         }
  69.         // 追加字符串也是一样的高效
  70.         int pos = _pos;
  71.         // 如果字符串长度为1 那么可以直接像追加字符一样
  72.         if (s.Length == 1 && (uint) pos < (uint) _chars .Length)
  73.         {
  74.             _chars[pos] = s[0];
  75.             _pos = pos + 1;
  76.         }
  77.         else
  78.         {
  79.             // 如果是多个字符 那么使用较慢的方法
  80.             AppendSlow(s);
  81.         }
  82.     }
  84.     private void AppendSlow(string s)
  85.     {
  86.         // 追加字符串 空间不够先扩容
  87.         // 然后使用Span复制 相当高效
  88.         int pos = _pos;
  89.         if (pos > _chars.Length - s.Length)
  90.         {
  91.             Grow(s.Length);
  92.         }
  94.         s
  95. #if !NETCOREAPP
  96.                 .AsSpan()
  97. #endif
  98.             .CopyTo(_chars.Slice(pos));
  99.         _pos += s.Length;
  100.     }
  102.     // 对于需要格式化的对象特殊处理
  103.     [MethodImpl(MethodImplOptions.AggressiveInlining)]
  104.     public void AppendSpanFormattable<T>(T value, string? format = null, IFormatProvider? provider = null)
  105.         where T : ISpanFormattable
  106.     {
  107.         // ISpanFormattable非常高效
  108.         if (value.TryFormat(_chars.Slice(_pos), out int charsWritten, format, provider))
  109.         {
  110.             _pos += charsWritten;
  111.         }
  112.         else
  113.         {
  114.             Append(value.ToString(format, provider));
  115.         }
  116.     }
  118.     [MethodImpl(MethodImplOptions.NoInlining)]
  119.     private void GrowAndAppend(char c)
  120.     {
  121.         // 单个字符扩容在添加
  122.         Grow(1);
  123.         Append(c);
  124.     }
  126.     // 扩容方法
  127.     [MethodImpl(MethodImplOptions.NoInlining)]
  128.     private void Grow(int additionalCapacityBeyondPos)
  129.     {
  130.         Debug.Assert(additionalCapacityBeyondPos > 0);
  131.         Debug.Assert(_pos > _chars.Length - additionalCapacityBeyondPos,
  132.             "Grow called incorrectly, no resize is needed.");
  134.         // 同样也是2倍扩容，默认从对象池中获取buffer
  135.         char[] poolArray = ArrayPool<char>.Shared.Rent((int) Math.Max((uint) (_pos + additionalCapacityBeyondPos),
  136.             (uint) _chars.Length * 2));
  138.         _chars.Slice(0, _pos).CopyTo(poolArray);
  140.         char[]? toReturn = _arrayToReturnToPool;
  141.         _chars = _arrayToReturnToPool = poolArray;
  142.         if (toReturn != null)
  143.         {
  144.             // 如果原本就是使用的对象池 那么必须归还
  145.             ArrayPool<char>.Shared.Return(toReturn);
  146.         }
  147.     }
  149.     //
  150.     [MethodImpl(MethodImplOptions.AggressiveInlining)]
  151.     public void Dispose()
  152.     {
  153.         char[]? toReturn = _arrayToReturnToPool;
  154.         this = default; // 为了安全，在释放时置空当前对象
  155.         if (toReturn != null)
  156.         {
  157.             // 一定要记得归还对象池
  158.             ArrayPool<char>.Shared.Return(toReturn);
  159.         }
  160.     }
  161. }

从上面的源码我们可以总结出ValueStringBuilder的几个特征：

  • 比起StringBuilder来说，实现方式非常简单。
  • 一切都是为了高性能，比如各种Span的用法，各种内联参数，以及使用对象池等等。
  • 内存占用非常低，它本身就是结构体类型，另外它是ref struct，意味着不会被装箱，不会在堆上分配。

适用场景

ValueStringBuilder是一种高性能的字符串创建方式，针对于不同的场景，可以有不同的使用方式。

1.非常高频次的字符串拼接的场景，并且字符串长度较小，此时可以使用栈上分配的ValueStringBuilder。

大家都知道现在ASP.NET Core性能非常好，在其依赖的内部库UrlBuilder中，就使用栈上分配，因为栈上分配在当前方法结束后内存就会回收，所以不会造成任何GC压力。



2.非常高频次的字符串拼接场景，但是字符串长度不可控，此时使用ArrayPool指定容量的ValueStringBuilder。比如在.NET BCL库中有很多场景使用，比如动态方法的ToString实现。从池中分配虽然没有栈上分配那么高效，但是一样的能降低内存占用和GC压力。



3. 非常高频次的字符串拼接场景，但是字符串长度可控，此时可以栈上分配和ArrayPool分配联合使用，比如正则表达式解析类中，如果字符串长度较小那么使用栈空间，较大那么使用ArrayPool。

需要注意的场景

1.在async\await中无法使用ValueStringBuilder。原因大家也都知道，因为ValueStringBuilder是ref struct，它只能在栈上分配，async\await会编译成状态机拆分await前后的方法，所以ValueStringBuilder不好在方法内传递，不过编译器也会警告。



2.无法将ValueStringBuilder作为返回值返回，因为在当前栈上分配，方法结束后它会被释放，返回它将指向未知的地址。这个编译器也会警告。



3.如果要将ValueStringBuilder传递给其它方法，那么必须使用ref传递，否则发生值拷贝会存在多个实例。这个编译器不会警告，但是你必须非常注意。



4. 如果使用栈上分配，那么Buffer大小控制在5KB内比较稳妥，至于为什么需要这样，后面有机会在讲一讲。

总结

今天和大家分享了一下高性能几乎无内存占用的字符串拼接结构体ValueStringBuilder，在大多数的场景还是推荐大家使用。但是要非常注意上面提到的的几个场景，如果不符合条件，那么大家还是可以使用高效的StringBuilder来进行字符串拼接。

本文源码链接: https://github.com/InCerryGit/BlogCode-Use-ValueStringBuilder

.NET性能优化-使用ValueStringBuilder拼接字符串的更多相关文章

  1. Mysql性能优化：如何给字符串加索引？

    导读 现代大部分的登录系统都支持邮箱.手机号码登录两种方式,那么如何在邮箱或者手机号码这个字符串上建立索引才能保证性能最佳呢? 今天这篇文章就来探讨一下在Mysql中如何给一个字符串加索引才能达到性能 ...

  2. java 性能优化 字符串过滤实战

    转自[http://www.apkbus.com/blog-822717-78335.html]  如有不妥联系删除!! ★一个简单的需求 首先描述一下需求:给定一个 String 对象,过滤掉除了数 ...

  3. AJPFX浅谈Java 性能优化之字符串过滤实战

    ★一个简单的需求 首先描述一下需求:给定一个 String 对象,过滤掉除了数字(字符'0'到'9')以外的其它字符.要求时间开销尽可能小.过滤函数的原型如下: String filter(Strin ...

  4. java性能优化--字符串优化处理

    String对象 String对象是java中重要的数据类型,在大部分情况下我们都会用到String对象.其实在Java语言中,其设计者也对String做了大量的优化工作,这些也是String对象的特 ...

  5. String字符串性能优化的几种方案

    String字符串是系统里最常用的类型之一,在系统中占据了很大的内存,因此,高效地使用字符串,对系统的性能有较好的提升. 针对字符串的优化,我在工作与学习过程总结了以下三种方案作分享: 一.优化构建的 ...

  6. String字符串性能优化的探究

    一.背景 String 对象是我们使用最频繁的一个对象类型,但它的性能问题却是最容易被忽略的.String 对象作为 Java 语言中重要的数据类型,是内存中占用空间最大的一个对象,高效地使用字符串, ...

  7. Java字符串之性能优化

    基础类型转化成String 在程序中你可能时常会需要将别的类型转化成String,有时候可能是一些基础类型的值.在拼接字符串的时候,如果你有两个或者多个基础类型的值需要放到前面,你需要显式的将第一个值 ...

  8. Java性能优化之String字符串优化

    字符串是软件开发中最重要的对象之一.通常,字符串对象在内存中是占据了最大的空间块,因此如何高效地处理字符串,必将是提高整体性能的关键所在. 1.字符串对象及其特点 Java中八大基本数据类型没有Str ...

  9. Sql动态查询拼接字符串的优化

    Sql动态查询拼接字符串的优化 最原始的 直接写:string sql="select * from TestTables where 1=1";... 这样的代码效率很低的,这样 ...

随机推荐

  1. Javascript Promises学习

    Promise对象的三个状态 pending(进行中) fulfilled(已成功) rejected(已失败) Promise代表一个异步操作,对象的状态一旦改变,就不会再改变 Promise构造函 ...

  2. 转载：23种常用设计模式的UML类图

    转载至:https://www.cnblogs.com/zytrue/p/8484806.html 23种常用设计模式的UML类图 本文UML类图参考<Head First 设计模式>(源 ...

  3. ACL 权限控制机制？

    UGO(User/Group/Others) 目前在 Linux/Unix 文件系统中使用,也是使用最广泛的权限控制方式.是一种粗 粒度的文件系统权限控制模式. ACL(Access Control ...

  4. composer安装报错

    问题报错:Fatal error: Declaration of Fxp\Composer\AssetPlugin\Repository\AbstractAssetsRepository::searc ...

  5. 使用Ansible部署openstack平台

    使用Ansible部署openstack平台 本周没啥博客水了,就放个云计算的作业上来吧(偷个懒) 案例描述 1.了解高可用OpenStack平台架构 2.了解Ansible部署工具的使用 3.使用A ...

  6. ROS机器人操作系统相关书籍、资料和学习路径

    作者:Top Liu链接:https://zhuanlan.zhihu.com/p/30391098来源:知乎著作权归作者所有.商业转载请联系作者获得授权,非商业转载请注明出处. 本文是易科机器人实验 ...

  7. 单片机ram和rom的区别

    单片机运行时需要调用某个程序/函数/固定数据时就需要读取ROM,然后在RAM中执行这些程序/函数的功能,所产生的临时数据也都存在RAM内,断电后这些临时数据就丢失了.ROM:(Read Only Me ...

  8. 前端基础问题整理-HTML相关

    DOCTYPE的作用以及常见的DOCTYPE类型 <!DOCTYPE>声明位于文档中的最前面的位置,处于 <html> 标签之前,用来告知浏览器页面目前的文件是用哪种版本的HT ...

  9. 制作html5微信页面的经验总结。

    先罗列一下我遇到的问题: 用户可选择图片上传,但是图片比较大(基本都是2M以上),而且还得异步上传. 由于操作上比较多的设计都是隐性的例如滑动之类,需要手势动画作提示. 块内元素滚动时不流畅,或不能滚 ...

  10. 【论文简读】 Deep web data extraction based on visual

    <Deep web data extraction based on visual information processing>作者 J Liu 上海海事大学 2017 AIHC会议登载 ...