泛型约束使用？有些不知道叫什么好！

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Data;
//----------
using Common;
using dataAccess;
using provider;
using modle;

namespace Common
{
    public class TestSingle<T> where T : class, new()
    {//通用的单一实例类基类,BusinessProvider继承此类
        private static T _Instance;
        public static T Instance
        {
            get
            {
                Interlocked.CompareExchange<T>(ref _Instance, new T(), null);
                return _Instance;
            }
        }

    }
}
namespace dataAccess
{
    public abstract class BusinessProvider<K> : TestSingle<K> where K : BusinessProvider<K>, new()
    {// 定义个抽象类 
        protected abstract string Database { get; }
        public void Delete(DataRow entity)
        {

        }
    }
}
namespace provider
{//数据操作，继承自抽象类
    public class UserInfoProvider : dataAccess.BusinessProvider<UserInfoProvider>
    {
        public modle.userinfo GetUserInfo()
        {
            modle.userinfo info = new modle.userinfo();
            return info;
        } 
    }
}

namespace Service
{//调用数据操作类
    public static class UserService
    {
        public static modle.userinfo getInfo()
        {//这里Instance.就可以象用使用NET的封装方法那样，直接点出GetUserInfo
            return provider.UserInfoProvider.Instance.GetUserInfo();
        }

    }
}

namespace modle
{
    public class userinfo
    {
        private int _uid;
        public int uid
        {
            get { return _uid;}
            set {_uid=value;}
        }
        private string _uname;
        public string  username
        {
            get { return _uname; }
            set { _uname = value; }
        }
    }
}

以前没有这么多逻辑来实现，一般也就bll dal model 三层，再复杂就加抽象工厂及接口  辅助工具类加个，一般也就这种模式

今天在研究一个没接触过的项目代码，Instance.GetUserInfo 这个方法吸引了我，很好奇他的实现。

于是花了一下午时间去剥离其流程，把主要的代码结构分享给大家