投机出轻量级ORM(三)

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 
 6 namespace Model.Entities
 7 {
 8     /// <summary>字段特性 
 9     /// 创建人:雷旭鹏(leo) 2014-1-13
10     /// 联系方式:leixupeng823@163.com 
11     /// </summary>
12     [AttributeUsage(AttributeTargets.Property, Inherited = false)]
13     public sealed class DBFieldAttribute : Attribute
14     {
15         /// <summary>字段名称 
16         /// </summary>
17         public string FieldName
18         {
19             get;
20             set;
21         }
22         /// <summary>键类型
23         /// </summary>
24         public DbKeyType KeyType
25         {
26             get;
27             set;
28         }
29         /// <summary>字段数据类型 
30         /// </summary>
31         public Type PropertyType
32         {
33             get;
34             set;
35         }
36         /// <summary>构造函数 
37         /// </summary>
38         public DBFieldAttribute()
39         { }
40     }
41 }

一样、函数的定义:

#len()
#len(s)
#len(s2)
#函数 mylen叫做函数称为
#def是要字 define
#():必须写
def mylen():
”’
计字符串长度的函数
”’
s = ‘hello world’
length = 0
for i in s:
length += 1
#print(‘s的长短是%s’%(length))
#print(length)
return length
#函数的调用:函数名+括号
leng = mylen()
print(leng)
#函数名
#总得由字母下划线数字构成,不克是至关重要字,不可知是数字开
#函数叫或如出得之含义能够简单说明函数的功力

# s2 = “hello egon”
# length = 0
# for i in s2:
# length += 1
# print(length)

定义:def
关键词起,空格之后接函数名及圆括声泪俱下(),最后还有一个”:”。

   def
是一贯的,不能够更换,必须是接连的def三个假名,不克分开。。。它们一旦亲相爱的于同步。

   空格
为了将def关键字与函数名分别,必须空(四声),当然你可空2格、3格还是你想空多少都实施,但正常人还是空1格。

   函数称呼:函数称呼只能分包字符串、下划线和数字都不可知为数字开头。虽然函数名为好凭起,但我们吃函数起名字或要硬着头皮简单,并能够表达函数功能

   括号:是必加以的,先转移问也底要产生括号,总的丰富括号就对准了!

注释:各级一个函数都应当对效益以及参数进行相应的征,应该写在函数下面第一推行。以提高代码的可读性。

调用:就是 函数名() 要记加上括号,好么好么好么。

达成同样首被概括分享了下ORM的筹划思路。现在始出口如何用代码来落实上篇的规划模型。

三、参数

#函数定义
def mylen(s1):
    """计算s1的长度"""
    length = 0
    for i in s1:
        length = length+1
    return length

#函数调用
str_len = mylen("hello world")
print('str_len : %s'%str_len)

我们告诉mylen函数要计算的字符串是何人,这个历程尽管被做 传递参数,简称传参,咱调用函数时传递的这个“hello
world”和概念函数时之s1就是参数

如实参与形参

参数还有个别:

我们调用函数时传递的之“hello
world”被称呼实在参数,因是是事实上的如付函数的内容,简称实参。

概念函数时的s1,只是一个变量的讳,被叫作形式参数,因为于概念函数的时候它只是是一个花样,表示此有一个参数,简称形参。  

传递多单参数

参数可以传递多独,多独参数之间用逗号分割。

def mymax(x,y):
    the_max = x if x > y else y
    return the_max

ma = mymax(10,20)
print(ma)

数据库的表会包含表名,字段名称,字段类型,主键,外键等根本要素。我们以档次遭到也各级张表建立一个Model类来抽象描述。

位置参数

透过添加地方的类,我们现在足本着数据库表展开抽象,用相应的表征标识字段是否也主键,外键或者也虚拟字段,SQL字段于.net类型的变换关系。各Model类之间的连年关系。

 站于形参角度

    1.职参数必须传值

def mymax(x,y):
    #此时x = 10,y = 20
    print(x,y)
    the_max = x if x > y else y
    return the_max

#调用mymax不传递参数
ma = mymax()
print(ma)

#结果
TypeError: mymax() missing 2 required positional arguments: 'x' and 'y'

   

 2.默服参数

    a.正常下

      使用方式

      为什么要出默认参数:将扭转于小之值设置成默认参数

    b.默认参数的概念

def stu_info(name,sex = "male"):
    """打印学生信息函数,由于班中大部分学生都是男生,
        所以设置默认参数sex的默认值为'male'
    """
    print(name,sex)


stu_info('alex')
stu_info('eva','female')

c.参数陷阱:默认参数是一个可变数据类型

def defult_param(a,l = []):
    l.append(a)
    print(l)

defult_param('alex')
defult_param('egon')

3.动态参数

  按职务传值多余的参数还出于args统一接受,保存成一个元组的形式

 a.*args

def func(a,b,*c):
    my_sum = a+b
    for i in c:
        my_sum += i
    return my_sum

#按位置传参数
# print(func(3,2))
# print(func(1,2,5,6))

b.**kwargs

def fun(a,b,**kwargs):
    print(a,b,kwargs)

# 按照关键字传参数
#fun(a = 10,b = 20,cccc= 30,dddd = 50)

本章小结

面向过程编程的题目:代码冗余、可读性差、可扩大性差(不易修改)

概念函数的平整:

起名 1

1.定义:def 关键词开头,空格之后接函数名称和圆括号()。
2.参数:圆括号用来接收参数。若传入多个参数,参数之间用逗号分割。
    参数可以定义多个,也可以不定义。
    参数有很多种,如果涉及到多种参数的定义,应始终遵循位置参数、*args、默认参数、**kwargs顺序定义。
    如上述定义过程中某参数类型缺省,其他参数依旧遵循上述排序
3.注释:函数的第一行语句应该添加注释。
4.函数体:函数内容以冒号起始,并且缩进。
5.返回值:return [表达式] 结束函数。不带表达式的return相当于返回 None

def 函数名(参数1,参数2,*args,默认参数,**kwargs):
        """注释:函数功能和参数说明"""
        函数体
        ……
        return 返回值

起名 2

调用函数的条条框框:

起名 3

1.函数名()
    函数名后面+圆括号就是函数的调用。
2.参数:
    圆括号用来接收参数。
    若传入多个参数:
        应按先位置传值,再按关键字传值
        具体的传入顺序应按照函数定义的参数情况而定
3.返回值
    如果函数有返回值,还应该定义“变量”接收返回值
    如果返回值有多个,也可以用多个变量来接收,变量数应和返回值数目一致

无返回值的情况:
函数名()

有返回值的情况:
变量 = 函数名()

多个变量接收多返回值:
变量1,变量2,... = 函数名()

 

本章小结

面向过程编程的问题:代码冗余、可读性差、可扩展性差(不易修改)

定义函数的规则:

复制代码
1.定义:def 关键词开头,空格之后接函数名称和圆括号()。
2.参数:圆括号用来接收参数。若传入多个参数,参数之间用逗号分割。
    参数可以定义多个,也可以不定义。
    参数有很多种,如果涉及到多种参数的定义,应始终遵循位置参数、*args、默认参数、**kwargs顺序定义。
    如上述定义过程中某参数类型缺省,其他参数依旧遵循上述排序
3.注释:函数的第一行语句应该添加注释。
4.函数体:函数内容以冒号起始,并且缩进。
5.返回值:return [表达式] 结束函数。不带表达式的return相当于返回 None

def 函数名(参数1,参数2,*args,默认参数,**kwargs):
        """注释:函数功能和参数说明"""
        函数体
        ……
        return 返回值
复制代码
调用函数的规则:

复制代码
1.函数名()
    函数名后面+圆括号就是函数的调用。
2.参数:
    圆括号用来接收参数。
    若传入多个参数:
        应按先位置传值,再按关键字传值
        具体的传入顺序应按照函数定义的参数情况而定
3.返回值
    如果函数有返回值,还应该定义“变量”接收返回值
    如果返回值有多个,也可以用多个变量来接收,变量数应和返回值数目一致

无返回值的情况:
函数名()

有返回值的情况:
变量 = 函数名()

多个变量接收多返回值:
变量1,变量2,... = 函数名()

def func():
    a = 111
    b = [1,2,3]
    #首先 返回值可以是任意的数据类型
    return b

#如果有返回值:必须要用变量接收才会有效果
# ret = func()
# print(ret)

def func1():
    a = 111
    b = [1,2,3]
# ret = func1()
# print(ret)
#函数可以没有返回值
#当不写return的时候,一个函数默认的返回值是'None'

def func2():
    a = 111
    b = [1,2,3]
    return
# ret = func2()
# print(ret)
#当只写一个return的时候,函数的返回值为None

def func3():
    a = 111
    b = [1,2,3]
    return None
# ret = func3()
# print(ret)
#return None的时候函数的返回值也为None(几乎不用)

def func4():
    print(1111)
    return
    print(2222)

# func4()

def func5():
    for i in range(20):
        if i == 5:
            return
        else:
            print(i)
# func5()

#总结:
#函数的返回值为None有三种情况
#1.不写返回值
#2.只写一个return
#3.return None  (几乎不用)
#return的作用:结束一个函数的执行

#函数的返回值不为None,有返回值
#return xxx  返回一个值(一个变量)
#return a,b  返回多个值(多个变量),多个值之间用逗号区分
            #接收:可以用一个变量接收,以元组的形式返回
            #      也可以用多个变量接收,返回几个就用几个变量去接收

#函数要先定义 后 调用

def func6():
    '''返回一个值'''
    #return 111
    #return 'abc'
    return ['abc',123]

def func7():
    '''返回多个值'''
    a = 123
    b = 'abc'
    return a,b,[1,2,3]

# ret = func7()
# print(ret)
# m,n,k = func7()
# print(m)
# print(n)
# print(k)

def func8():
    l = [1,2,3,4]
    return l[-1]

# ret = func8()
# print(ret)

def mylen(s):  #参数接收:形式参数,形参
    '''
    计算字符串长度的函数        ——函数的功能
    参数s:接收要计算的字符串   ——参数的信息
    return:要计算的字符串长度  ——返回值的信息
    '''
    #s = "helloworld"
    length = 0
    for i in s:
        length += 1
    return length

#参数
# sss = "helloworld"
# length1 = mylen(sss) #参数传入:实际参数,实参
# length2 = mylen('1234') #参数传入:实际参数,实参
# length3 = mylen('egon is somebody') #参数传入:实际参数,实参
# length4 = mylen('hello') #参数传入:实际参数,实参
# print(length1)
# print(length2)
# print(length3)
# print(length4)
#函数的定义
#函数的调用
#函数的返回值
#函数的参数
    #实参和形参
    #实参:函数调用的时候传入的参数值
    #形参:是函数定义的时候定义的参数名
    #参数可以是任意的数据类型
    #可以传递0个或多个参数
    #位置参数:按顺序定义参数
    #默认参数:首先,不要设置可变数据类型的默认参数
               #对于变化小的参数可以设置默认参数
               #默认参数可以不传,不传的时候用的就是默认值
               #如果传,会覆盖默认值
               #默认的值是在定义函数的时候就已经确定了的
    #调用函数时传参数:
        #按照位置传参
        #按照关键字传参

def my_max(a,b):  #定义:位置参数
    '''返回两个值之间的最大值'''
    print(a,b)
    if a > b:
        return a
    else:
        return b

# print(my_max(10,20))
# print(my_max(30,20))
#站在传参的角度上
#按照位置传参数
# my_max(10,20)
#按照关键字传参数
#my_max(b = 10,a = 20)

# def func(a):
#     print(a)
# func('a')
def login(user,pwd):
    if user == 'egon' and pwd == 'somebody':
        return True
    else:
        return False

# ret = login('egon','somebody')
# if ret:
#     print('登录成功')

def stu_info(name,sex = 'male'):  #默认参数,有一个默认值
    print('name:%s,sex:%s'%(name,sex))

# stu_info('李淑旗') #默认参数可以不传值
# stu_info('高大鹏')
# stu_info('海燕','female') #如果传值了,覆盖默认值

s = 'male'
def stu_info(name,sex = s):  #默认参数,有一个默认值
    print('name:%s,sex:%s'%(name,sex))
# s = 'female' #不影响定义时sex的值
# stu_info("李淑旗")
b = []
def func(a = []): #不要设置可变数据类型的默认参数
    a.append(1)
    print(a)
# func()
# func()
# func()
# func()

# func([])
# func([])
# func([])
# func([])

def my_max(a,b=5):#位置参数、默认参数
    if a>b:
        return a
    else:
        return b
#print(my_max(b = 10,a = 20)) #按照位置传和按照关键字传

#参数
#位置参数
#默认参数
#动态参数
    #*args
    #**kwargs
def func(a,b,*c):
    my_sum = a+b
    for i in c:
        my_sum += i
    return my_sum

#按位置传参数
# print(func(3,2))
# print(func(1,2,5,6))


def fun(a,b,**kwargs):
    print(a,b,kwargs)

# 按照关键字传参数
#fun(a = 10,b = 20,cccc= 30,dddd = 50)

# def f(a,b,*args,defult=6,**kwargs):
#     #位置参数,*args,默认参数,**kwargs
#     print(a,b,args,defult)
#
# #传参数的时候:必须先按照位置传参数,再按照关键字传参数
# f(1,2,7,8,defult=10)

def fun2(*args):#*args代表把散列的元素拼成元组
    print(args)
t = (1,2,3,4)
l = [1,2,3,4]
# fun2(t[0],t[1],t[2],t[3])
fun2(*t)  #*代表把一个元组、列表拆了
fun2(*l)  #*代表把一个元组、列表拆了

def fun3(**kwargs):#*args代表把按关键字传来的参数拼成字典
    print(kwargs)
fun3(a = 10, b = 20)
d = {'a': 10, 'b': 20}
fun3(**d)  #*代表把一个字典拆了

#为什么要用函数
#1.避免代码重用
#2.提高代码的可读性

#函数的定义
def 函数名(参数1,参数2):
    '''函数注释'''
    print("函数体")
    return "返回值"

#函数调用
返回值 = 函数名(参数1,参数2)

#函数定义——返回值
#关键字:return
#return的作用:
    #1.结束函数的执行
    #2.返回要返回的值
#返回值的两种情况:
    #返回值为None
    #返回值不为None
        #1.返会一个值
        #2.返回多个值

#函数调用——接收返回值
#返回值为None   不接收
#返回值不为None
    # 1.返会一个值
            #用一个变量接收
    # 2.返回多个值
            #用一个变量接收,接收的结果是一个元组
            #有多少个返回值就用多少个变量接收

#参数——站在定义函数的角度上
#1.位置参数
#2.默认参数
#3.动态参数
    #*args
    #**kwargs
#顺序 位置参数 *args 默认参数 **kwargs

#参数——站在调用函数的角度上
#1.按照位置传参
#2.按照关键字传参
#3.动态传参 *tup **dic

 

起名 4起名 5

  站在实参角度

    1.按岗位传值

def mymax(x,y):
    #此时x=10,y=20
    the_max = x if x > y else y
    return the_max

ma = mymax(10,20)
print(ma)

2.论重点字传值

def mymax(x,y):
    #此时x = 20,y = 10
    print(x,y)
    the_max = x if x > y else y
    return the_max

ma = mymax(y = 10,x = 20)
print(ma)

3.职位、关键字形式混在用

def mymax(x,y):
    #此时x = 10,y = 20
    print(x,y)
    the_max = x if x > y else y
    return the_max

ma = mymax(10,y = 20)
print(ma)

对用法

      问题一样:位置参数必须在事关重大字参数的先头

      问题二:对于一个形参只能赋值一潮  

 

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 
 6 namespace Model.Entities
 7 {
 8     /// <summary>所属表属性 
 9     /// 创建人:雷旭鹏(leo) 2014-1-13
10     /// 联系方式:leixupeng823@163.com 
11     /// </summary>
12     [AttributeUsage(AttributeTargets.Property, Inherited = false)]
13     public sealed class DBTableAttribute : Attribute
14     {
15         /// <summary>表名称
16         /// </summary>
17         public string TableName
18         {
19             get;
20             set;
21         }
22         /// <summary>表昵称
23         /// </summary>
24         public string TableNickName
25         {
26             get;
27             set;
28         }
29         /// <summary>构造函数 
30         /// </summary>
31         public DBTableAttribute()
32         {
33         }
34     }
35 }

次、函数的返回值

def func():
    a = 111
    b = [1,2,3]
    #首先 返回值可以是任意的数据类型
    return b

#如果有返回值:必须要用变量接收才会有效果
# ret = func()
# print(ret)

def func1():
    a = 111
    b = [1,2,3]
# ret = func1()
# print(ret)
#函数可以没有返回值
#当不写return的时候,一个函数默认的返回值是'None'

def func2():
    a = 111
    b = [1,2,3]
    return
# ret = func2()
# print(ret)
#当只写一个return的时候,函数的返回值为None

def func3():
    a = 111
    b = [1,2,3]
    return None
# ret = func3()
# print(ret)
#return None的时候函数的返回值也为None(几乎不用)

def func4():
    print(1111)
    return
    print(2222)

# func4()

def func5():
    for i in range(20):
        if i == 5:
            return
        else:
            print(i)
# func5()

#总结:
#函数的返回值为None有三种情况
#1.不写返回值
#2.只写一个return
#3.return None  (几乎不用)
#return的作用:结束一个函数的执行

#函数的返回值不为None,有返回值
#return xxx  返回一个值(一个变量)
#return a,b  返回多个值(多个变量),多个值之间用逗号区分
            #接收:可以用一个变量接收,以元组的形式返回
            #      也可以用多个变量接收,返回几个就用几个变量去接收

#函数要先定义 后 调用

def func6():
    '''返回一个值'''
    #return 111
    #return 'abc'
    return ['abc',123]

def func7():
    '''返回多个值'''
    a = 123
    b = 'abc'
    return a,b,[1,2,3]

# ret = func7()
# print(ret)
# m,n,k = func7()
# print(m)
# print(n)
# print(k)

def func8():
    l = [1,2,3,4]
    return l[-1]

# ret = func8()
# print(ret)

咱俩无非待以函数的末梢加上一个return,return后面写上而如回到的值就是好了。

对接下,我们就来研讨一下之return的用法。

return关键字的意

  return
是一个关键字,在pycharm里,你晤面看出它们化蓝色了。你要一字不差的把这个单词给背下去。

  这个词翻译过来就是“返回”,所以我们无论写于return后面的值叫“返回值”

要是钻返回值,我们还要懂得回值有几乎栽情况:分别是从未回来值、返回一个价值、返回多个价值

从未返回值

  不写return的动静下,会默认返回一个None起名:我们描绘的首先单函数,就从未写return,这就是是不曾返回值的平栽情景。 

#函数定义
def mylen():
    """计算s1的长度"""
    s1 = "hello world"
    length = 0
    for i in s1:
        length = length+1
    print(length)

#函数调用
str_len = mylen()
#因为没有返回值,此时的str_len为None
print('str_len : %s'%str_len)

 

     
 只写return,后面不写其他情节,也会回到None,有的同学会奇怪,既然没有如回的价值,完全可以无写return,为什么还要写个return呢?这里我们只要说一样下return的别样用法,就是假如遇到return,结束所有函数

def ret_demo():
    print(111)
    return
    print(222)

ret = ret_demo()
print(ret)

只写return

 

      return None:和方的星星种情景亦然,我们一般不这样描写。

def ret_demo():
    print(111)
    return None
    print(222)

ret = ret_demo()
print(ret)

 

回一个价值

     
刚刚我们早就勾勒了一个回来一个价值的情事,只需要于return后面写及使回到的始末即可。

#函数定义
def mylen():
    """计算s1的长度"""
    s1 = "hello world"
    length = 0
    for i in s1:
        length = length+1
    return length

#函数调用
str_len = mylen()
print('str_len : %s'%str_len)

 

  

     顾:return和返回值之间要出空格,可以回任意数据类型的值

返回多个价

  可以返回任意多只、任意数据类型的值

def ret_demo1():
    '''返回多个值''' 
    return 1,2,3,4


def ret_demo2():
    '''返回多个任意类型的值'''
    return 1,['a','b'],3,4

ret1 = ret_demo1()
print(ret1)
ret2 = ret_demo2()
print(ret2)

 

       返回的基本上个值会被集体成元组被归,也足以用几近只价来接纳

def ret_demo2():
    return 1,['a','b'],3,4

#返回多个值,用一个变量接收
ret2 = ret_demo2()
print(ret2)

#返回多个值,用多个变量接收
a,b,c,d = ret_demo2()
print(a,b,c,d)

#用多个值接收返回值:返回几个值,就用几个变量接收
a,b,c,d = ret_demo2()
print(a,b,c,d)

解压缩扩展

#序列解压一
>>> a,b,c,d = (1,2,3,4)
>>> a
>>> b
>>> c
>>> d
#序列解压二
>>> a,_,_,d=(1,2,3,4)
>>> a
>>> d
>>> a,*_=(1,2,3,4)
>>> *_,d=(1,2,3,4)
>>> a
>>> d
#也适用于字符串、列表、字典、集合
>>> a,b = {'name':'eva','age':18} 
>>> a
'name'
>>> b
'age'

 

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 
 6 namespace Model.Entities
 7 {
 8     /// <summary>
 9     /// 创建人:雷旭鹏(leo) 2014-1-13
10     /// 联系方式:leixupeng823@163.com
11     /// </summary>
12     public enum TableJoinType : int
13     {
14         INNER_JOIN = 0,
15         LEFT_JOIN = 1,
16         RIGHT_JOIN = 2
17     }
18 }

咱先行由Model层开始。

如:

以Model类中我们定义常量TableName,用来讲述数据库表名称。为表的字段逐一添加Model类属性,属性名和字段名相同。

DAL层为 SQL增删改查操作的法抽象封装

咱俩打2个类库来分别抽象数据库表结构涉及映射和SQL增删改查操作。

 

DBTypeAttribute类为标识字段对应SQLSERVER字段类型标识类

Model层为多少库表结构关系映射

 

起名 6

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 using System.Data;
 6 namespace Model.Entities
 7 {
 8     [AttributeUsage(AttributeTargets.Property, Inherited = false)]
 9     public sealed class DBTypeAttribute : Attribute
10     {
11          /// <summary>SQL数据库字段类型
12         /// </summary>
13         public SqlDbType SqlDBType
14         {
15             get;
16             set;
17         }
18         /// <summary>构造函数 
19         /// </summary>
20         public DBTypeAttribute()
21         {
22         }
23     }
24 }

 

View Code

字段会生出主键,外键标识或是虚拟字段标识。我们当字段属性上加加于定义特性类DBField来讲述他们。

DBFieldAttribute类为字段键值特性标识类

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 using Model.Entities;
 6 using System.Data;
 7 namespace Model
 8 {
 9     [Serializable]
10     public class EmpInfoModel : BaseEntity
11     {
12         /// <summary>是否可以修改
13         /// </summary>
14         public const bool isCanMod = false;
15         /// <summary>数据库表名
16         /// </summary>
17         public const String TableName = "EmpInfo";
18         public EmpInfoModel()
19         { }
20 
21         private string _Id;
22         private string _Name;
23         private int? _isAllMoneyCheck;
24         private Guid? _MyGuid;
25         private Int16? _MySmallint;
26         private bool? _MyBool;
27         private string _Myntext;
28         [DBField(KeyType = DbKeyType.PK)]//主键标识
29         [DBType(SqlDBType = SqlDbType.NVarChar)]//字段对应SQLSERVER数据库字段类型
30         public virtual string Id
31         {
32             set { _Id = value; }
33             get { return _Id; }
34         }
35 
36         public string Name
37         {
38             set { _Name = value; }
39             get { return _Name; }
40         }
41 
42 
43         public int? isAllMoneyCheck
44         {
45             set { _isAllMoneyCheck = value; }
46             get { return _isAllMoneyCheck; }
47         }
48 
49         [DBType(SqlDBType = SqlDbType.UniqueIdentifier)]//字段对应SQLSERVER数据库字段类型
50         public Guid? MyGuid
51         {
52             set { _MyGuid = value; }
53             get { return _MyGuid; }
54         }
55 
56         [DBType(SqlDBType = SqlDbType.SmallInt)]//字段对应SQLSERVER数据库字段类型
57         public Int16? MySmallint
58         {
59             set { _MySmallint = value; }
60             get { return _MySmallint; }
61         }
62 
63         [DBType(SqlDBType = SqlDbType.Bit)]//字段对应SQLSERVER数据库字段类型
64         public bool? MyBool
65         {
66             set { _MyBool = value; }
67             get { return _MyBool; }
68         }
69         [DBType(SqlDBType = SqlDbType.NText)]//字段对应SQLSERVER数据库字段类型
70         public string Myntext
71         {
72             set { _Myntext = value; }
73             get { return _Myntext; }
74         }
75     }
76 }

DBJoinAttribute类为涉表连接类型特性标识类

起名 7

出于SQL字段类型和.net数据类型不等同,我们于字段属性上添加起定义特性类DBType来描述对应之SQL字段类型。

DBTableAttribute类用于连接是标识相应表名

DbKeyType类为字段键值枚举类,枚举值包含字段否也主键,外键,无,和虚构字段。

本人于Model类库下加加DbKeyType类,TableJoinType类,DBFieldAttribute类,DBJoinAttribute类,DBTableAttribute类,DBTypeAttribute类。

开拓VS2010,新建2个类库。分别于名叫吧Model,和DAL。

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 
 6 namespace Model.Entities
 7 {
 8     /// <summary>
 9     /// 创建人:雷旭鹏(leo) 2014-1-13 
10     /// 联系方式:leixupeng823@163.com
11     /// </summary>
12     public enum DbKeyType:int
13     {
14         Filed = 0,
15         PK = 1,
16         FK = 2,
17         /// <summary>只用于承载数据
18         /// </summary>
19         DataFiled = 3
20     }
21 }

TableJoinType为表连接类型枚举类

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 
 6 namespace Model.Entities
 7 {
 8     /// <summary>链接属性 
 9     /// 创建人:雷旭鹏(leo) 2014-1-13
10     /// 联系方式:leixupeng823@163.com
11     /// </summary>
12     [AttributeUsage(AttributeTargets.Property, Inherited = false)]
13     public sealed class DBJoinAttribute : Attribute
14     {
15         /// <summary>主键
16         /// </summary>
17         public string PK
18         {
19             get;
20             set;
21         }
22         /// <summary>外键 
23         /// </summary>
24         public string FK
25         {
26             get;
27             set;
28         }
29         /// <summary>表连接关系
30         /// </summary>
31         public TableJoinType JoinType
32         {
33             get;
34             set;
35         }
36         /// <summary>构造函数
37         /// </summary>
38         public DBJoinAttribute()
39         { }
40     }
41 }

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图