计算机教程

当前位置:澳门娱乐场网址 > 计算机教程 > C澳门娱乐场网址:#中的where泛型约束介绍

C澳门娱乐场网址:#中的where泛型约束介绍

来源:http://www.ablakeforum.com 作者:澳门娱乐场网址 时间:2019-06-01 06:30

复制代码 代码如下:

澳门娱乐场网址 1

  ///
  /// 中国人
  ///
  public class Chinese : INationality
  {
      private string _Nationality;
      public string Nationality
      {
          set
         {
             _Nationality = value;
         }
     }

(5)开放式构造类型和封闭式构造类型可以用作方法参数。

 ///
 /// 国籍的接口
 ///
 public interface INationality
 {
     string Nationality
     {
         set;
         get;
     }
     string GetNationality();
 }

泛型接口
(1)泛型类型参数可指定多重接口约束。

复制代码 代码如下:

(4)泛型类型可以使用多个类型参数和约束。

  ///
  public class PrintNationality where T : INationality, new()
  {
      T item = new T();
      public void Print()
      {
         Console.WriteLine(string.Format("Nationality:{0}", item.GetNationality()));
      }
  }

复制代码 代码如下:

然后创建一个泛型类,带有泛型约束的类,如下:

复制代码 代码如下:

由于有where字句的泛型约束,所以,创建PrintNationality的对象时,T的类型只能是继承子INationality接口的类。

复制代码 代码如下:

您可能感兴趣的文章:

(2)泛型方法的类型参数可以进行约束。
(3)泛型方法可以使用许多类型参数进行重载。

复制代码 代码如下:

interface IDictionary<K, V>
{
}

然后该接口有两个实现,如下:

class NodeItem<T> where T : System.IComparable<T>, new() { }
class SpecialNodeItem<T> : NodeItem<T> where T : System.IComparable<T>, new() { }

  ///
  ///
  ///

泛型类 泛型类封装不是特定于具体数据类型的操作。 泛型类最常用于集合,如链接列表、哈希表、堆栈、队列、树等。 像从集合中添加和移除项这样的操作都以大体上相同的方式执行,与所存储数据的类型无关。对大多集合类的操作,推荐使用 .NET Framework 类库中所提供的类。
(1)泛型类可以继承具体类、封闭式构造、开放式构造基类。

     public string GetNationality()
     {
         return string.IsNullOrEmpty(_Nationality) ? "Default." : _Nationality;
     }
 }
 ///
 /// 美国人
 ///
 public class American : INationality
 {
     private string _Nationality;
     public string Nationality
     {
         set { _Nationality = value; }
     }

泛型方法 包含类型参数声明的方法即为泛型方法。
(1)泛型类的类型参数与它内部泛型方法的类型参数一致,编译器将生成警告 CS0693。

  public class Program
  {
      static void Main(string[] args)
      {
          PrintNationality _c = new PrintNationality();
          PrintNationality _a = new PrintNationality();
          //PrintNationality _o = new PrintNationality(); 此句是错误的,因为泛型类型必须是继承自INationality接口的类
          _c.Print();
          _a.Print();
         Console.ReadKey();
     }
 }

(3)类继承规则适用接口继承规则。(参考上面泛型类继承)
(4)泛型接口实例

复制代码 代码如下:

class GenericInterface
    {
        static void Main()
        {
            SortedList<Person> list = new SortedList<Person>();
            string[] names = new string[]
            {
                "zhang san",
                "li si",
                "wang wu",
                "zhou er",
                "he yi"
            };
            int[] ages = new int[] { 22, 15, 30, 34, 12 };
            for (int x = 0; x < 5; x )
            {
                list.AddNode(new Person(names[x], ages[x]));
            }
            foreach (Person p in list)
            {
                System.Console.WriteLine(p.ToString());
            }
            Console.WriteLine("------------------排序-----------------------");
            list.BublleSort();
            foreach (Person p in list)
            {
                System.Console.WriteLine(p.ToString());
            }
            Console.Read();
        }
    }
    public class GenericList<T> : System.Collections.Generic.IEnumerable<T>
    {
        public class Node
        {
            private T data;
            public T Data
            {
                get { return data; }
                set { data = value; }
            }
            private Node next;
            public Node Next
            {
                get { return next; }
                set { next = value; }
            }
            private Node last;
            public Node Last
            {
                get { return last; }
                set { last = value; }
            }
            public Node(T t)
            {
                data = t;
                next = null;
            }
        }
        public Node firstNode;
        private Node lastNode;
        public void AddNode(T t)
        {
            Node node = new Node(t);
            node.Last = lastNode;
            if (lastNode != null)
                lastNode.Next = node;
            lastNode = node;
            if (firstNode == null)
                firstNode = node;
        }
        #region IEnumerable<T> 成员
        public IEnumerator<T> GetEnumerator()
        {
            Node current = firstNode;
            while (current != null)
            {
                //yield return表达式以枚举对象返回
                yield return current.Data;
                current = current.Next;
            }
        }
        #endregion
        #region IEnumerable 成员
         //IEnumerable < T >继承自IEnumerable,
        //因此这类必须实现泛型和非泛型的版本的GetEnumerator。
        //在大多数情况下,非泛型方法简单调用泛型方法。
        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
        #endregion
    }
    public class SortedList<T> : GenericList<T> where T : System.IComparable<T>
    {
        //该方法实现排序
        public void BublleSort()
        {
            if (firstNode == null || firstNode.Next == null)
                return;
            bool swapped;
            do
            {
                Node last = null;
                Node current = firstNode;
                swapped = false;
                while (current.Next != null)
                {
                    if (current.Data.CompareTo(current.Next.Data) > 0)
                    {
                        /* 当前节点大于下一个节点,位置交换*/
                        Node tmp = current.Next;
                        current.Next = current.Next.Next;
                        tmp.Next = current;
                        if (last == null)
                        {
                            firstNode = tmp;
                        }
                        else
                        {
                            last.Next = tmp;
                        }
                        last = tmp;
                        swapped = true;
                    }
                    else
                    {
                        last = current;
                        current = current.Next;
                    }
                }
            }
            while (swapped);
        }
    }
    public class Person : System.IComparable<Person>
    {
        string name;
        int age;
        public Person(string n, int a)
        {
            name = n;
            age = a;
        }
        #region IComparable<Person> 成员
        public int CompareTo(Person p)
        {
            //按年龄排序
            //return age - p.age;
            //按名称排序
            int a =name.CompareTo(p.name);
            return a;
        }
        #endregion
        public override string ToString()
        {
            return name ":" age;
        }
    }

泛型约束的意思就是说:类的泛型,只能是where字句后面所写的接口或类。
这么说好像也有点不大明白,举个例子。
我有一个接口,如下:

复制代码 代码如下:

以上的代码运行结果:

(3)从开放式构造类型继承的泛型类必须指定约束,这些约束是基类型约束的超集或暗示基类型约束。

     public string GetNationality()
     {
         return string.IsNullOrEmpty(_Nationality) ? "Default." : _Nationality;
     }
 }

class SuperKeyType<K, V, U>
    where U : System.IComparable<U>
    where V : new()
{ }

本文由澳门娱乐场网址发布于计算机教程,转载请注明出处:C澳门娱乐场网址:#中的where泛型约束介绍

关键词: