精华内容
下载资源
问答
  • 有时我们会有通过反射来动态构造泛型类型的需求,该如何实现呢?举个栗子,比如我们常常定义的泛型委托Func<in T, out TResult>,当T或TResult的类型需要根据程序上下文来确定时,也就是说我们的泛型委托类型...

    有时我们会有通过反射来动态构造泛型类型的需求,该如何实现呢?举个栗子,比如我们常常定义的泛型委托Func<in T, out TResult>,当T或TResult的类型需要根据程序上下文来确定时,也就是说我们的泛型委托类型是动态确定的,那么如何来构造呢?答案就是typeof(Func<,>).MakeGenericType(typeof(T), typeof(TResult))

    一、先来看下Type.MakeGenericType的描述。

    // C:\Program Files\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.6.1\mscorlib.dll
    namespace System
    {
            //
            // 摘要:
            //     替代由当前泛型类型定义的类型参数组成的类型数组的元素,并返回表示结果构造类型的 System.Type 对象。
            //
            // 参数:
            //   typeArguments:
            //     将代替当前泛型类型的类型参数的类型数组。
            //
            // 返回结果:
            //     System.Type 表示的构造类型通过以下方式形成:用 typeArguments 的元素取代当前泛型类型的类型参数。
            //
            // 异常:
            //   T:System.InvalidOperationException:
            //     当前的类型不表示泛型类型定义。也就是说, System.Type.IsGenericTypeDefinition 返回 false。
            //
            //   T:System.ArgumentNullException:
            //     typeArguments 为 null。- 或 - 任何元素 typeArguments 是 null。
            //
            //   T:System.ArgumentException:
            //     中的元素数 typeArguments 不是当前的泛型类型定义中的类型参数的编号相同。- 或 - 任何元素 typeArguments 不满足当前的泛型类型的相应类型参数指定的约束。-
            //     或 - typeArguments 包含的元素,是指针类型 (System.Type.IsPointer 返回 true),通过 ref 类型 (System.Type.IsByRef
            //     返回 true),或 System.Void。
            //
            //   T:System.NotSupportedException:
            //     在基类中不支持调用的方法。派生类必须提供一个实现。
            public virtual Type MakeGenericType(params Type[] typeArguments);
    }

    二、示例

    通过MakeGenericType方法,从Func<T,TResult>泛型委托类型创建出特定类型Func<string,Object>的委托类型。

        class Program
        {
            static void Main(string[] args)
            {
                Console.WriteLine("\r\n--- 通过基本的泛型委托类型构造特定类型的委托类型。");
                
                //创建一个类型对象,表示基本的泛型委托类型。
                //要省略类型参数(但保留类型参数之间的逗号,使编译器能够推断出参数数量)。
                Type generic = typeof(Func<,>);
                DisplayTypeInfo(generic);
                
                //创建类型数组以替代泛型委托的类型参数,
                //输入参数类型为string,输出参数类型为Object。
                Type[] typeArgs = { typeof(string), typeof(Object) };
                
                //创建特定类型的泛型委托类型对象
                Type constructed = generic.MakeGenericType(typeArgs);
                DisplayTypeInfo(constructed);
    
                //再通过typeof()直接创建一个类型对象
                Type t = typeof(Func<String, Object>);
    
                Console.WriteLine("\r\n--- 比较两种方法得到的类型:");
                Console.WriteLine("\t两种类型是否相等? {0}", t == constructed);
                Console.WriteLine("\t两种类型的泛型类型定义是否相等? {0}",t.GetGenericTypeDefinition() == generic);
                Console.Read();
            }
            private static void DisplayTypeInfo(Type t)
            {
                Console.WriteLine("\r\n{0}", t);
                Console.WriteLine("\t是否泛型类型定义? {0}",t.IsGenericTypeDefinition);
                Console.WriteLine("\t是否泛型类型? {0}",t.IsGenericType);
    
                Type[] typeArguments = t.GetGenericArguments();
                Console.WriteLine("\t枚举类型参数 ({0}):", typeArguments.Length);
                foreach (Type tParam in typeArguments)
                {
                    Console.WriteLine("\t\t{0}", tParam);
                }
            }
        }

    输出
    524552-20180427172641934-2115979915.png

    转载于:https://www.cnblogs.com/jiujiduilie/p/8654576.html

    展开全文
  • 解决办法:利用数组构造器 问题描述 比如表达式new T[n],这样创建会产生错误,因为这会被改为new object[n] 例如:我们需要建立一个person对象数组,Stream接口有一个toArray方法可以实现返回object数组 Object[] ...

    解决办法:利用数组构造器

    问题描述

    比如表达式new T[n],这样创建会产生错误的,因为这会被改为new object[n]

    例如:我们需要建立一个person对象数组,Stream接口有一个toArray方法可以实现返回object数组

    Object[] person =Stream.toArray();

    但是我们想要得到的是一个person引用数组,而不是Object引用数组

    流库利用构造器可以解决这个问题,可以把person[]::new传入toArray方法:

    Person[] person = stream.toArray(person[]::new);

    toArray调用这个构造器来调用得到一个正确类型的数组,然后填充这个数组并返回

    展开全文
  • 泛型类型

    2021-04-25 21:12:34
    1.下面定义一个带一个参数的泛型类型,并调用相应在这里插入代码片的方法实现。 //含有一个类型参数的泛型类型 public class Node <T>{ private T value ; //泛型成员 public Node(){} //默认构造方法 ...

    泛型类型

    泛型是类和接口的一种扩展机制,主要实现参数化类型机制,简单地说,泛型是带一个参数或多个参数的类或者接口。

    1.下面定义一个带一个参数的泛型类型,并调用相应在这里插入代码片的方法实现。

    //含有一个类型参数的泛型类型
    public class Node <T>{
        private T value ; //泛型成员
        public Node(){} //默认构造方法
        public Node(T value){ //带一个参数的构造方法
            this.value = value ;
        }
        public T get(){ //访问方法
            return value ;
        }
        public void set(T value){ //修改方法
            this.value = value ;
        }
        public void showType(){  //显示类型名的方法
            System.out.println("T的类型名:" + value.getClass().getName()) ;
        }
    
        public static void main(String[] args){
            Node <Integer> node = new Node<>()  ; //实例化泛型对象
            node.set(new Integer(3)) ; //设置泛型对象的值
            System.out.println(node.get()) ; //输出访问对象的值
            node.showType() ; //输出泛型的类型
            Node <Integer> node1 = new Node<>(new Integer(1)) ;
            System.out.println(node1.get()) ;
            node1.showType() ;
        }
    }
    
    

    2.下面定义一个带一个参数的泛型类型实现一个接口。

    //含有两个类型参数的泛型类型
    interface Entry<K,V>{ //泛型接口
        public K getKey() ;
        public V getValue() ;
    }
    public class Pair <K,V> implements Entry<K,V>{//泛型类Pair实现泛型接口Entry
        private K key ; //泛型成员
        private V value ;
        public Pair(){}
        public Pair(K key, V value){ //带两个参数的构造方法
            this.key = key ;
            this.value = value ;
        }
        @Override
        public K getKey() { //访问键的方法
            return key;
        }
    
        @Override
        public V getValue() { //访问值的方法
            return value;
        }
        public void setKey(K key){ //修改键的方法
            this.key = key ;
        }
        public void setValue(V value){ //修值的方法
            this.value = value ;
        }
        public void print(){ //自定义的得到键和值的方法
            System.out.println(getKey() + " " + getValue()) ;
        }
        public static void main(String[] args){
            Pair <String,Integer> p1 = new Pair<>() ;//实例化泛型对象p1
            p1.setKey("twenty") ; //修改键
            p1.setValue(20) ; //修改值
    System.out.println(p1.getKey() + " " + p1.getValue()) ; //访问p1对象的键和值
     Pair <String,String> p2 = new Pair<>("China","Beijing") ; //实例化泛型对象p2
            p2.print(); //调用print()方法打印键值对
        }
    }
    
    
    展开全文
  • static class Program { static void Main(string[] args) { var aaa = Create<AAA>("aaa"); aaa.AAAAAA(); var bbb = Create<BBB>(...
     static class Program
        {
            static void Main(string[] args)
            {
                var aaa = Create<AAA>("aaa");
                aaa.AAAAAA();
                var bbb = Create<BBB>("bbb");
                bbb.BBBBBB();
                Console.ReadKey();
    
            }
            static T Create<T>(string connString)
            {
                return (T)Activator.CreateInstance(typeof(T), new object[] { connString });
            }
        }
        public class AAA
        {
            private string str;
            public AAA(string input)
            {
                str = input;
            }
            public string AAAAAA()
            {
                return "AAA" + str;
            }
        }
        public class BBB
        {
            private string str;
            public BBB(string input)
            {
                str = input;
            }
            public string BBBBBB()
            {
                return "BBB" + str;
            }
        }

     

    转载于:https://www.cnblogs.com/luludongxu/p/5669729.html

    展开全文
  • 泛型类中对于其方法,有时需要获得它的字节码对象作为该方法参数,这时如何获取可以用以下方法 ...,用type的一个ParameterizedType实现类型接收父类集合,取第一个即为运行时期的父类的泛型类型的字节码对象 ...
  • 泛型类型参数

    2019-09-26 23:37:54
    泛型类型或方法中,类型参数是客户端在实例化泛型类型的变量时,指定特定类型占位符。 若要使用GenericList<T>,客户端代码必须通过指定尖括号中类型参数来声明和实例化构造类型。此特定类类型参数...
  • 1 internal sealed class GenericTypeThatRequireAnEnum<T> 2 { 3 public static int age = 12;... 5 //静态构造器针对每个封闭类型都会执行一次,泛型类型定义静态构造目的就是为了保证传递类型...
  • “T”必须是具有公共无参数构造函数非抽象类型,才能用作泛型类型或方法。如图: 找了好久,终于让我给找到原因了。分享给大家。呵呵 1. 我要项目中用到泛型类型的有: 【说明】大家看了截图,...
  • class Other<T> { public class Inner<U, V> { static Inner() { Console.WriteLine("Other<{0}>.Inner<{1},{2}>...
  • 泛型是包含类型参数抽象类型类型构造器; 抽象类型不能作为类型直接定义变量; 必须先具体化; 泛型类型构造器。 构造器+参量类型空间 = 具体类型; 具体类型 = 泛型 + 参量类型空间。 泛型是...
  • 泛型类型参数

    2011-03-17 15:21:00
    泛型类型参数 在泛型类型或方法定义中,类型参数是客户端在实例化泛型类型的变量时指定特定类型占位符。泛型类(如泛型介绍(C# 编程指南)中列出 GenericList)不可以像这样使用,因为它实际上并不是一...
  • 数据类型使用了泛型,在后续更改中,更换数据类型只需要少许变更代码 层序遍历 利用Node类level属性 所有属性权限全为public ,为了方便先这么写吧,建议还是用private来写. 还有个问题,值得注意, 就是先序...
  • C#的泛型类型参数可以有带参数的构造函数的约束方式吗? 原文:C#的泛型类型参数可以有带参数的构造函数的约束方式吗?Review后看到标题让我十分羞愧自己语文功底太差,估计...请见谅......我还...
  • 反射_02反射类型和泛型类型

    千次阅读 2011-06-13 16:31:00
    反射类型和泛型类型从反射的角度来说,泛型类型和普通类型的区别在于,泛型类型与一组类型参数(如果是泛型类型定义)或类型变量(如果是构造的类型)关联。泛型方法与普通方法的区别也在于此。反射的问题在于提供一...
  • class TypeofOperator { static internal void DemonstrateTypeof&lt;X&gt;() { Console.WriteLine(typeof(X)); //显示方法的类型参数 Console.WriteLine(typeof(List&lt;...
  • C#—泛型类型参数

    千次阅读 2019-07-03 09:52:35
    泛型类型或泛型方法定义中,类型参数是一个占位符(placeholder),通常为一个大写字母,如T。在客户代码声明、实例化该类型变量时,把T替换为客户代码所指定数据类型。泛型类,如泛型概述中给出MyList类...
  • 每个不同的类型实参列表都被看作一个不同封闭类型 int转换成Int32 string转换成String object转换成Object 输出 Outer<Int32>.Inner,DateTime> Outer<String>.Inner,Int32> Outer<Object>.Inner,Object> Outer...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,281
精华内容 912
关键字:

构造的泛型类型