C# 泛型类型参数的约束

最新推荐文章于 2023-07-26 00:00:34 发布
最新推荐文章于 2023-07-26 00:00:34 发布
阅读量809 收藏
点赞数
分类专栏： .Net 文章标签： 泛型 c#

C# 泛型类型参数的约束

http://www.cnblogs.com/rinack/p/5676311.html
在定义泛型类时，可以对客户端代码能够在实例化类时用于类型参数的类型种类施加限制。如果客户端代码尝试使用某个约束所不允许的类型来实例化类，则会产生编译时错误。这些限制称为约束。约束是使用 where 上下文关键字指定的。下表列出了六种类型的约束：


where T: struct
类型参数必须是值类型。可以指定除 Nullable 以外的任何值类型。有关更多信息，请参见使用可以为 null 的类型（C# 编程指南）。
where T : class
类型参数必须是引用类型；这一点也适用于任何类、接口、委托或数组类型。
where T：new()
类型参数必须具有无参数的公共构造函数。当与其他约束一起使用时，new() 约束必须最后指定。
where T：<基类名>
类型参数必须是指定的基类或派生自指定的基类。
where T：<接口名称>
类型参数必须是指定的接口或实现指定的接口。可以指定多个接口约束。约束接口也可以是泛型的。
where T：U
为 T 提供的类型参数必须是为 U 提供的参数或派生自为 U 提供的参数。

使用约束的原因  
 
如果要检查泛型列表中的某个项以确定它是否有效，或者将它与其他某个项进行比较，则编译器必须在一定程度上保证它需要调用的运算符或方法将受到客户端代码可能指定的任何类型参数的支持。这种保证是通过对泛型类定义应用一个或多个约束获得的。例如，基类约束告诉编译器：仅此类型的对象或从此类型派生的对象才可用作类型参数。一旦编译器有了这个保证，它就能够允许在泛型类中调用该类型的方法。约束是使用上下文关键字 where 应用的。 

public class Employee
{
    private string name;
    private int id;

    public Employee(string s, int i)
    {
        name = s;
        id = i;
    }

    public string Name
    {
        get { return name; }
        set { name = value; }
    }

    public int ID
    {
        get { return id; }
        set { id = value; }
    }
}

public class GenericList<T> where T : Employee
{
    private class Node
    {
        private Node next;
        private T data;

        public Node(T t)
        {
            next = null;
            data = t;
        }

        public Node Next
        {
            get { return next; }
            set { next = value; }
        }

        public T Data
        {
            get { return data; }
            set { data = value; }
        }
    }

    private Node head;

    public GenericList() //constructor
    {
        head = null;
    }

    public void AddHead(T t)
    {
        Node n = new Node(t);
        n.Next = head;
        head = n;
    }

    public IEnumerator<T> GetEnumerator()
    {
        Node current = head;


        while (current != null)
        {
            yield return current.Data;
            current = current.Next;
        }
    }

    public T FindFirstOccurrence(string s)
    {
        Node current = head;
        T t = null;

        while (current != null)
        {
            //The constraint enables access to the Name property.
            if (current.Data.Name == s)
            {
                t = current.Data;
                break;
            }
            else
            {
                current = current.Next;
            }
        }
        return t;
    }
}


约束使得泛型类能够使用 Employee.Name 属性，因为类型为 T 的所有项都保证是 Employee 对象或从 Employee 继承的对象。
可以对同一类型参数应用多个约束，并且约束自身可以是泛型类型，如下所示：

class EmployeeList<T> where T : Employee, IEmployee, System.IComparable<T>, new()
{
    // ...
}
 
通过约束类型参数，可以增加约束类型及其继承层次结构中的所有类型所支持的允许操作和方法调用的数量。因此，在设计泛型类或方法时，如果要对泛型成员执行除简单赋值之外的任何操作或调用 System.Object 不支持的任何方法，您将需要对该类型参数应用约束。
在应用 where T : class 约束时，避免对类型参数使用 == 和 != 运算符，因为这些运算符仅测试引用同一性而不测试值相等性。即使在用作参数的类型中重载这些运算符也是如此。下面的代码说明了这一点；即使 String 类重载 == 运算符，输出也为 false。 

public static void OpTest<T>(T s, T t) where T : class
{
    System.Console.WriteLine(s == t);
}
static void Main()
{
    string s1 = "target";
    System.Text.StringBuilder sb = new System.Text.StringBuilder("target");
    string s2 = sb.ToString();
    OpTest<string>(s1, s2);
}

这种情况的原因在于，编译器在编译时仅知道 T 是引用类型，因此必须使用对所有引用类型都有效的默认运算符。如果必须测试值相等性，建议的方法是同时应用 where T : IComparable<T> 约束，并在将用于构造泛型类的任何类中实现该接口。

约束多个参数

可以对多个参数应用约束，并对一个参数应用多个约束，如下面的示例所示：

class Base { }
class Test<T, U>
    where U : struct

    where T : Base, new() { }


未绑定的类型参数

没有约束的类型参数（如公共类 SampleClass<T>{} 中的 T）称为未绑定的类型参数。未绑定的类型参数具有以下规则：

不能使用 != 和 == 运算符，因为无法保证具体类型参数能支持这些运算符。

可以在它们与 System.Object 之间来回转换，或将它们显式转换为任何接口类型。

可以将它们与 null 进行比较。将未绑定的参数与 null 进行比较时，如果类型参数为值类型，则该比较将始终返回 false。

作为约束的类型参数

将泛型类型参数作为约束使用，在具有自己类型参数的成员函数必须将该参数约束为包含类型的类型参数时非常有用，如下示例所示：

class List<T>
{
    void Add<U>(List<U> items) where U : T {/*...*/}

}


在上面的示例中，T 在 Add 方法的上下文中是一个类型约束，而在 List 类的上下文中是一个未绑定的类型参数。

类型参数还可在泛型类定义中用作约束。请注意，必须在尖括号中声明此类型参数与任何其他类型的参数：

//Type parameter V is used as a type constraint.
public class SampleClass<T, U, V> where T : V { }
泛型类的类型参数约束的作用非常有限，因为编译器除了假设类型参数派生自 System.Object 以外，不会做其他任何假设。在希望强制两个类型参数之间的继承关系的情况下，可对泛型类使用参数类型约束。
========

泛型类型参数及约束

http://www.cnblogs.com/wanghonghu/archive/2012/07/11/2586920.html
泛型类型参数简介
    在定义泛型类型和泛型方法时，常用到泛型类型参数，泛型类型参数是在实例化泛型时指定类型的占位符。泛型类型参数放在“<>”内。

    泛型类型参数命名建议：

    （1）当泛型类型参数为单个字母时，建议用T表示。

    （1）当泛型类型参数用单词定义时，建议在单词前加T。

private void PromptName<T>(T t) {}
private void PromptName<Tuser>(Tuser user){}
泛型类型参数约束
      在定义泛型类时，可以对在实例化泛型类时用于类型参数的类型种类施加限制。如果实例化泛型类时使用某个约束所不允许的类型来实例化类，则会产生编译时错误。

      泛型约束分类：  

约束

说明

T：结构

类型参数必须是值类型。 可以指定除 Nullable 以外的任何值类型。

T：类

类型参数必须是引用类型；这一点也适用于任何类、接口、委托或数组类型。

T：new()

类型参数必须具有无参数的公共构造函数。 当与其他约束一起使用时，new() 约束必须最后指定。

T：<基类名>

类型参数必须是指定的基类或派生自指定的基类。

T：<接口名称>

类型参数必须是指定的接口或实现指定的接口。 可以指定多个接口约束。 约束接口也可以是泛型的。

T：U

为 T 提供的类型参数必须是为 U 提供的参数或派生自为 U 提供的参数。

 （1）类型参数约束为结构（struct）。 

    public class ShowObjectType<T> where T : struct
    {
        public void ShowValue<T>(T t)
        {
            Console.WriteLine(t.GetType());
        }
    }

    class GenericConstraint
    {
        static void Main()
        {          
            ShowObjectType<int> showInt = new ShowObjectType<int>();
            showInt.ShowValue<int>(5);
            showInt.ShowValue(5);//从参数可以推导出类型参数类型，则可以省略类型参数类型
            
            //因为约束为值类型，下面代码不能通过编译
            ShowObjectType<string> showString = new ShowObjectType<string>();
            showString.ShowValue("5");

            Console.Read();
        }
    }


   （2）类型参数约束为类（class）。

    在应用 where T : class 约束时，避免对类型参数使用 == 和 != 运算符，因为这些运算符仅测试类型为引用类型，而不测试值相等性。 

    class GenericConstraint
    {
        static void Main()
        {
              List<string > list = new List<string>();
            AddClass<string>(list, "hello generic");

            Console.Read();
        }

        private static void AddClass<T>(List<T> list, T t) where T : class
        {
            list.Add(t);
        }
    }

  （4）类型参数约束为具体类。

         约束为具体类时，可利用类型参数调用具体类的属性和方法。

    class GenericConstraint
    {
        static void Main()
        {
            Person person = new Person { ID = 1, Name = "David" };
            PromptName<Person>(person);


            Console.Read();
        }


        //此约束T为Person对象或者继承Person对象
        private static void PromptName<T>(T t) where T : Person 
        {
            //此处可使用Person的Name属性
            if (t.Name == "David")
            {
                Console.WriteLine("Person name is David");
            }


            string name = t.GetName();
            Console.WriteLine("Person name is {0}", name);
        }
    }
    public class Person
    {
        private int id;
        public int ID
        {
            get { return id; }
            set { id = value; }
        }


        private string name;
        public string Name
        {
            get { return name; }
            set { name = value; }
        }
        public string GetName()
        {
            return Name;
        }
    }
复制代码
    （5）约束多个参数。


class Base { }
class Test<T, U>
    where U : struct
    where T : Base, new() { }
    （6）未绑定类型参数。


      没有约束的类型参数，称为未绑定的类型参数。


class  List<T>{}
========

泛型类型参数约束 <T> where T : class,new(){}



.NET支持的类型参数约束有以下五种：
where T : struct                               | T必须是一个结构类型
where T : class                               | T必须是一个类（class）类型，不能是结构(structure)类型   引用类型
where T : new()                               | T必须要有一个无参构造函数    可以被new（）
where T : NameOfBaseClass          | T必须继承名为NameOfBaseClass的类
where T : NameOfInterface             | T必须实现名为NameOfInterface的接口
========

where（泛型类型约束）

http://www.cnblogs.com/lystory/p/5104865.html
定义：在定义泛型的时候，我们可以使用 where 限制参数的范围。


使用：在使用泛型的时候，你必须尊守 where 限制参数的范围，否则编译不会通过。


六种类型的约束：


T：类（类型参数必须是引用类型；这一点也适用于任何类、接口、委托或数组类型。）


    class MyClass<T, U>
        where T : class///约束T参数必须为“引用 类型{ }”
        where U : struct///约束U参数必须为“值 类型”
    { }
T：结构（类型参数必须是值类型。可以指定除 Nullable 以外的任何值类型。）


    class MyClass<T, U>
        where T : class///约束T参数必须为“引用 类型{ }”
        where U : struct///约束U参数必须为“值 类型”
    { }
T：new()（类型参数必须具有无参数的公共构造函数。当与其他约束一起使用时，new() 约束必须最后指定。）


class EmployeeList<T> where T : Employee, IEmployee, System.IComparable<T>, new()
{
    // ...
}
T：<基类名>（类型参数必须是指定的基类或派生自指定的基类。）


public class Employee{}


public class GenericList<T> where T : Employee
T：<接口名称>（类型参数必须是指定的接口或实现指定的接口。可以指定多个接口约束。约束接口也可以是泛型的。）


复制代码
    /// <summary>
    /// 接口
    /// </summary>
    interface IMyInterface
    {
    }


    /// <summary>
    /// 定义的一个字典类型
    /// </summary>
    /// <typeparam name="TKey"></typeparam>
    /// <typeparam name="TVal"></typeparam>
    class Dictionary<TKey, TVal>
        where TKey : IComparable, IEnumerable
        where TVal : IMyInterface
    {
        public void Add(TKey key, TVal val)
        {
        }
    }
复制代码
T：U（为 T 提供的类型参数必须是为 U 提供的参数或派生自为 U 提供的参数。也就是说T和U的参数必须一样）


class List<T>
{
    void Add<U>(List<U> items) where U : T {/*...*/}
}
 


一、可用于类：


public class MyGenericClass<T> where T:IComparable { }
二、可用于方法：


public bool MyMethod<T>(T t) where T : IMyInterface { }
三、可用于委托：


delegate T MyDelegate<T>() where T : new()
 


在实际项目中什么时候用到它们？


有时候你在做一个项目的时候，你需要用到泛型，你只希望传给你的泛型参数是限定范围的，


比如你希望值类型，或者是引用类型，或者是继承至某个类型、或者是符合某个接扣的类型，


这个时候你该如何办？你就需要用到 WHERE 来限定了。


 


参考文档：


https://msdn.microsoft.com/zh-cn/library/d5x73970.aspx


https://msdn.microsoft.com/zh-cn/library/bb384067.aspx
========

c# 泛型类型参数与约束的深入分析

http://www.jb51.net/article/37657.htm
本篇文章是对c#中泛型类型参数与约束进行了详细的分析介绍，需要的朋友参考下
..泛型类型参数简介
在定义泛型类型和泛型方法时，常用到泛型类型参数，泛型类型参数是在实例化泛型时指定类型的占位符。泛型类型参数放在“<>”内。
泛型类型参数命名建议：
（1）当泛型类型参数为单个字母时，建议用T表示。
（2）当泛型类型参数用单词定义时，建议在单词前加T。


复制代码 代码如下:
private void PromptName<T>(T t) {}
private void PromptName<Tuser>(Tuser user){}


泛型类型参数约束
在定义泛型类时，可以对在实例化泛型类时用于类型参数的类型种类施加限制。如果实例化泛型类时使用某个约束所不允许的类型来实例化类，则会产生编译时错误。
泛型约束分类：  


约束
 说明
 
T：结构
 类型参数必须是值类型。 可以指定除 Nullable 以外的任何值类型。 
 
T：类
 类型参数必须是引用类型；这一点也适用于任何类、接口、委托或数组类型。
 
T：new()
 类型参数必须具有无参数的公共构造函数。 当与其他约束一起使用时，new() 约束必须最后指定。
 
T：<基类名>
 类型参数必须是指定的基类或派生自指定的基类。
 
T：<接口名称>
 类型参数必须是指定的接口或实现指定的接口。 可以指定多个接口约束。 约束接口也可以是泛型的。
 
T：U
 为 T 提供的类型参数必须是为 U 提供的参数或派生自为 U 提供的参数。
 


（1）类型参数约束为结构（struct）。


复制代码 代码如下:
public class ShowObjectType<T> where T : struct
    {
        public void ShowValue<T>(T t)
        {
            Console.WriteLine(t.GetType());
        }
    }
    class GenericConstraint
    {
        static void Main()
        {


            ShowObjectType<int> showInt = new ShowObjectType<int>();
            showInt.ShowValue<int>(5);
            showInt.ShowValue(5);//从参数可以推导出类型参数类型，则可以省略类型参数类型


            //因为约束为值类型，下面代码不能通过编译
            ShowObjectType<string> showString = new ShowObjectType<string>();
            showString.ShowValue("5");
            Console.Read();
        }
    }


（2）类型参数约束为类（class）。
在应用 where T : class 约束时，避免对类型参数使用 == 和 != 运算符，因为这些运算符仅测试类型为引用类型，而不测试值相等性。


复制代码 代码如下:
class GenericConstraint
    {
        static void Main()
        {
              List<string > list = new List<string>();
            AddClass<string>(list, "hello generic");
            Console.Read();
        }
        private static void AddClass<T>(List<T> list, T t) where T : class
        {
            list.Add(t);
        }
    }


（3）类型参数约束为具体类。
约束为具体类时，可利用类型参数调用具体类的属性和方法。


复制代码 代码如下:
class GenericConstraint
    {
        static void Main()
        {
            Person person = new Person { ID = 1, Name = "David" };
            PromptName<Person>(person);
            Console.Read();
        }
        //此约束T为Person对象或者继承Person对象
        private static void PromptName<T>(T t) where T : Person 
        {
            //此处可使用Person的Name属性
            if (t.Name == "David")
            {
                Console.WriteLine("Person name is David");
            }
            string name = t.GetName();
            Console.WriteLine("Person name is {0}", name);
        }
    }
    public class Person
    {
        private int id;
        public int ID
        {
            get { return id; }
            set { id = value; }
        }
        private string name;
        public string Name
        {
            get { return name; }
            set { name = value; }
        }
        public string GetName()
        {
            return Name;
        }
    }


（4）约束多个参数。


复制代码 代码如下:
class Base { }
class Test<T, U>
    where U : struct
    where T : Base, new() { }


（5）未绑定类型参数。
 没有约束的类型参数，称为未绑定的类型参数。


复制代码 代码如下:
class  List<T>{}


========
bcbobo21cn
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#面试问答总结1
jonsen的专栏
11-12 2042
1、用.net做B/S结构的系统，您是用几层结构来开发，每一层之间的关系以及为什么要这样分层？  答： 从下至上分别为：数据访问层、业务逻辑层（又或成为领域层）、表示层       数据访问层：有时候也称为是持久层，其功能主要是负责数据库的访问        业务逻辑层：是整个系统的核心，它与这个系统的业务（领域）有关        表示层：是系统的UI部分，负责使用者与整个系统的交
C#中的泛型
weixin_66598341的博客
04-03 949
主要介绍了C#中的泛型
多个类型参数约束的C＃泛型语法[重复]
CHCH998的博客
06-12 2128
Possible Duplicate: 可能重复： Generic methods and multiple constraints 通用方法和多个约束 I need a generic
c# 泛型类型参数与约束的深入分析
12-26
代码如下:private void PromptName(T t) {}private void PromptName(Tuser user){}泛型类型参数约束在定义泛型类时，可以对在实例化泛型类时用于类型参数的类型种类施加限制。如果实例化泛型类时使用某个约束所不...
详解C#泛型的类型参数约束
12-17
约束告知编译器类型参数必须具备的功能。 在没有任何约束的情况下，类型参数可以是任何类型。 编译器只能假定 System.Object 的成员，它是任何 .NET 类型的最终基类。 如果客户端代码使用不满足约束的类型，编译器将...
C#泛型约束的深入理解
12-25
基类约束：指出某个类型必须将指定的类作为基类（或者就是该类本身），才能用作该泛型类型的类型参数。这样的约束一经使用，就必须出现在该类型参数的所有其他约束之前。 代码如下:class MyClassy<T>where T : class...
C#图解教程 第十七章 泛型
weixin_30321449的博客
02-10 213
泛型 什么是泛型 一个栈的示例 C#中的泛型 继续栈示例 泛型类声明泛型类创建构造类型创建变量和实例 使用泛型的栈的示例比较泛型和非泛型栈 类型参数的约束 Where子句约束类型和次序 泛型方法 声明泛型方法调用泛型方法 推断类型 泛型方法示例 扩展方法和泛型类泛型结构泛型委托 另一个 泛型委托示例 泛型接口 使用泛型接口的示例泛型接口的实现必须唯一 协...
C# EF常用约束写法
音尘啊
02-22 907
做个笔记： 文章转自博客园，原文地址：EF常用约束写法 侵删！ 一、通过Attribute配置约束 1、主键约束 通过KeyAttribute来配置主键约束,代码如下: [Key] public int PrimaryKey{ get; set; } 2、外键约束 通过ForeignKeyAttribute来配置外键约束,代码如下: [Key] public int PrimaryKey{ get; set; } [ForeignKey("ForeignKey")] public int PrimaryK
C#规范整理·泛型委托事件
最新发布
weixin_68436326的博客
07-26 395
基于泛型，我们得以将类型参数化，以便更大范围地进行代码复用。同时，它减少了泛型类及泛型方法中的转型，确保了类型安全。委托本身是一种引用类型，它保存的也是托管堆中对象的引用，只不过这个引用比较特殊，它是对方法的引用。事件本身也是委托，它是委托组，C#中提供了关键字event来对事件进行特别区分。  一旦我们开始编写稍微复杂的C#代码，就肯定离不开泛型、委托和事件。1.总是优先考虑泛型#泛型的...
c#泛型约束
LM001_csdn的博客
07-31 2448
泛型约束的使用以及可作用场景
[译]聊聊C＃中的泛型的使用（新手勿入）
依乐祝的博客
11-27 560
写在前面 今天忙里偷闲在浏览外文的时候看到一篇讲C#中泛型的使用的文章，因此加上本人的理解以及四级没过的英语水平斗胆给大伙进行了翻译，当然在翻译的过程中发现了一些问题，因此也进行了纠正，当然，原文的地址我放在最下面，如果你的英文水平比较好的话，可以直接直接阅读全文。同时最近建了一个.NET Core实战项目交流群637326624，有兴趣的朋友可以来相互交流。目前.NET Core实战项...
C#泛型的理解/为什么要使用泛型/什么是泛型/怎么用泛型
ahang的博客
01-12 2379
1、为什么要使用泛型 我们在编写程序时,经常遇到两个模块的功能非常相似,只是一个是处理int数据,另一个是处理string数据,或者其他自定义的数据类型,但我们没有办法,只能分别写多个方法处理每个数据类型,因为方法的参数类型不同。有没有一种办法,在方法中传入通用的数据类型,这样不就可以合并代码了吗?泛型的出现就是专门解决这个问题的。 泛型在实例化对象的时候，使用这个对象需要的类型 读完本篇文章,你会对泛型有更深的了解。 我们先简单的看一下下面的需求及其解释,后面我们会详细讲解里面的具体特性。 我们现.
C# ORM中反射与泛型的交叉应用 - 动态创建泛型实例并为其赋值
SmileSB101-(ZXB)的博客
07-19 3688
好久没有写文章了，终于找到工作，抽空写一下冒个泡。问题最近遇到一个这样 ORM 的问题，一个返回类型为 List 泛型方法中，需要做到根据条件访问数据库，并且把得到的结果存入 List 中返回。由于只是以前学过一段时间的 C#，而且反射一直个人认为是各中难点，加上泛型，这篇文章纯属个人纪录，如有错误，望各位大佬指正。分析根据条件访问数据库 ==> 遍历获取到的 reader 对象 ==> 创建泛型
C#在类的属性对非法值的进行限定的三种方法
weixin_46096032的博客
11-25 1830
为了防止用户输入或传入非法值，我们往往需要对类中的属性进行限定。比如在登录系统中，限定密码为数字则必须输入数字，对于年龄的限定必须为0~120，对于性别的设定必须为男或女，现在介绍三种限定方法 属性是用于保护和限定字段的，属性的限定一般是set和get方法，其中set方法是在给属性赋值的时候执行 的，而get则是在对属性进行打印调用的时候使用的 首先我们先创建一个person类，和类下的字段和属性 public class Person//非静态类 { string _name;/
c# 泛型约束
03-27 548
例如，如果您编写一个需要使用“+”运算符的方法，但是类型参数 T 并不一定包含此运算符，则可以使用 where T : IAddable 约束来限制 T 必须实现 IAddable 接口，该接口定义了“+”运算符。在这个例子中，方法使用 where T : IAddable 约束，以确保 T 实现了 IAddable 接口，该接口定义了“+”运算符。where T : struct - 此约束指定 T 必须是值类型。where T : class - 此约束指定 T 必须是引用类型。
c# ienumerable 赋值_【c#进阶】我们为什么要用泛型
weixin_39677106的博客
11-30 390
本文的部分内容来源于《more effective c#》，在此声明。c#里面的泛型相较于其他语言来说更加灵活，因为我们不但可以使用泛型函数，甚至可以使用泛型类，我们在使用它们的时候，它们会自行检测你传入参数的类型，因此，它可以为我们省去大量的时间，不用一个个编写方法的重载，与此同时，使用泛型会提升程序的效率。使用泛型的时候，我们的编程习惯大都使用 T 来表示泛型的类型，那么我们举一个例子，来体会...
泛型类型参数的默认值
05-30
泛型类型参数没有默认值，...此外，如果泛型类型参数没有指定约束条件，default 会返回 null，这可能会导致空引用异常。因此，在使用 default 关键字时，应该根据情况选择合适的约束条件，以确保程序的正确性和可靠性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值