泛型 接口约束:
using System;
namespace ConsoleApp1
{
/*
*
* 接口约束:where T:interfaceName
* T是类型形参的名称,interfaceName是接口名称,
* 接口约束是 指定某个类型实参必须实现的接口。
* 它的两个主要的功能和基类约束一样,允许开发人员在泛型类中使用接口中的成员;确保只能使用实现了特定接口的类型实参。
* 也就是说,对任何给定的接口约束,类型实参必须是接口本身或者是实现了该接口的类。
*
*/
class Program
{
static void Main(string[] args)
{
Console.WriteLine(Compare<int>.CompareData(3, 12));//12
}
}
/// <summary>
/// 接口约束,T的类型用IComparable这个接口来约束
/// 也就是说T的类型就是IComparable接口,用T可以调用它里面的任何方法,只要你愿意,这也就实现了接口约束的目的,即你要使用我这个接口,就必须按照我的规定来!
/// </summary>
/// <typeparam name="T"></typeparam>
public class Compare<T> where T : IComparable
{
// 定义一个方法,返回值类型为 T , 其两个形参也是T类型的
// 方法的功能:返回较大值
public static T CompareData(T n1,T n2)
{
// 调用IComparable接口中方法CompareTo(),这个方法的返回值类型为int
return n1.CompareTo(n2) > 0 ? n1 : n2;
//先不考虑两值相等的时候
}
}
}
普通 单例模式:
class Program
{
static void Main(string[] args)
{
//使用单例:类名.静态方法() <----获取到实例对象,然后再用对象调用它里面的其他方法即可
var str = Singleton.getInstance().Outresult("我是输出内容....");
Console.WriteLine(str);
}
}
/// <summary>
/// 单例模式-----即一个函数只允许有一个实例对象!
/// </summary>
public class Singleton
{
// 首先定义一个Singleton类型的对象(必须静态的,不然调用它还要实例化,相悖了....),intance就是Singleton类的唯一实例对象
public static Singleton instance;
// 一个获取实例对象的方法
public static Singleton getInstance()
{
// 只有当Singleton类型的对象不存在时(即本类的实例对象),才去创建这样一个对象!
if (instance == null)
{
instance = new Singleton();
}
return instance;
}
// 本类中一个输出方法(测试用的)
public string Outresult(string str)
{
return str;
}
}
上面用到的是类中一个方法来获取类的唯一实例对象
那完全也可以用属性的访问器来初始化一个类的对象啊,如下:
public class Singleton
{
public static Singleton instance;
// 用属性的get访问器 生成单例的对象
public static Singleton Instance
{
get
{
if (instance == null)
{
instance = new Singleton();
}
return instance;
}
}
//其他输出方法......
}
调用的话:var str = Singleton.Instance.Outresult(“我是输出内容…”);
综上:两种方式实现单例
泛型 new()约束:父类是一个单例类
using System;
namespace ConsoleApp1
{
/*
*
* new()构造函数约束: where T: new()
* 它允许开发人员实例化一个泛型类型的对象。
* new()约束要求类型实参必须提供一个无参数的公有构造函数。
* 使用new()约束时,可以通过调用该无参构造器来创建对象。
*
* 注意:
* 1. new()在与其他约束一起使用时,必须放在约束列表的末端
* 2. 仅允许使用无参构造器构造一个对象,即使同时存在其他的构造器也是如此。即不允许给类型形参的构造器传递实参。
* 3. 不可以同时使用new()约束和值类型约束。因为值类型都是隐式的提供一个无参公共构造器。就如同定义接口时指定访问类型为public一样,编译器会报错,因为接口一定是public的!!!
*
*/
class Program
{
static void Main(string[] args)
{
Console.WriteLine(Person.Instance.getPerson());
Console.WriteLine(Student.Instance.getStudent());
Console.WriteLine(Person.Instance.Outresult());
Console.ReadKey();
}
}
/// <summary>
/// 单例模式-----即一个函数只允许有一个实例对象!
/// </summary>
public class Singleton<T> where T : new()
{
private static T instance;
// 用属性的get访问器 生成单例的对象
public static T Instance
{
get
{
if (instance == null)
{
// 这里创建的不再是一个Singleton对象,而是T对象
instance = new T();
// 这样写会报错:变量类型 T 没有new()约束,因此无法创建该类型的实例
//解决:类上面写new()的约束......
}
return instance;
}
}
// 本类中一个输出方法(测试用的)
public string Outresult()
{
return "this method in Singleton";
}
}
/*
* 对于继承Singleton的类,必须要有一个无参构造器,因为他有new()约束!!!
*
*/
// Person类继承Singleton类,就必须指定T的类型,这里指定为Person....
public class Person : Singleton<Person>
{
public string getPerson()
{
return "this method in Person class";
}
}
public class Student : Singleton<Student>
{
public string getStudent()
{
return "this method in Student";
}
}
}
组合约束:
/*
* 五种约束:
*
* where T:struct 值类型约束----类型参数必须为值类型
*
* where T:class 引用类型约束:适用于类、接口、委托、数组等----类型参数必须为引用类型
*
* where T:new() new()约束-----类型参数必须有一个公有的无参构造器
*
* where T:<base class name> 基类约束-----类型参数必须是指定的基类或是派生自指定的基类
*
* where T:<interface> 接口约束-----类型参数必须是指定接口或实现指定的接口,可以指定多个接口约束,约束接口也可以是泛型的
*
*
* 组合约束:用的不多,基本都是别人封装好的,我们拿来直接调用即可
* 同一个类型形参可以使用多个约束。逗号隔开
* 在约束列表中,第一个必须是引用类型约束或者值类型约束,或者是基类约束,然后才是接口约束,最后才是new()约束
* 指定引用类型约束或值类型约束的同时也指定基类约束是非法的
*
* 例如:
* class Test<T> where T : Myclass, Interface, new(){......}
* 替换T的类型实参必须是继承Myclass类,实现Interface接口,且拥有一个无参构造器
*
* 在使用两个或多个类型形参时,也可以使用多条where子句分别为它们指定约束
*
*/