函数

 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 }

 站在形参角度

    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.参数陷阱:暗中认可参数是1个可变数据类型

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

 

DB菲尔德Attribute类为字段键值天性标识类

② 、函数的重回值

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)

咱俩只须求在函数的最终加上3个return,return前面写上您要重回的值就足以了。

接下去,大家就来研商一下以此return的用法。

return关键字的职能

  return
是三个重要字,在pycharm里,你会面到它变成北京蓝了。你必须一字不差的把那一个单词给背下来。

  那几个词翻译过来就是“重回”,所以大家管写在return前面包车型地铁值叫“再次回到值”

要研讨重临值,大家还要领悟重回值有三种景况:分别是从未再次来到值、重回2个值、再次回到五个值

尚无重临值

  不写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)

 

回到二个值

     
刚刚大家早已写过3个回到叁个值的处境,只需在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     [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 }

三、参数

#函数定义
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,只是八个变量的名字,被称呼方式参数,因为在概念函数的时候它只是1个样式,表示那里有3个参数,简称形参。  

传送八个参数

参数能够传递多少个,多个参数之间用逗号分割。

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

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

起名 4

  站在实参角度

    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 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 }

① 、函数的概念:

#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格。

   函数名:函数名只可以分包字符串、下划线和数字且不能够以数字先导。固然函数名能够任由起,但大家给函数起名字或然要尽量简单,并能表明函数功效

   括号:是必须加的,先别问何故要有括号,总而言之丰盛括号就对了!

注释:每二个函数都应当对效益和参数进行对应的表达,应该写在函数上边第3行。以抓好代码的可读性。

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

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

职位参数

是因为SQL字段类型和.net数据类型差异,大家在字段属性上添加自定义天性类DBType来讲述对应的SQL字段类型。

大家建三个类库来分别抽象数据库表结构关系映射和SQL增加和删除改查操作。

 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类来抽象描述。

DAL层为 SQL增加和删除改查操作的点子抽象封装

 

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

如:

 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 }

起名 5起名 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 }

DBTypeAttribute类为标识字段对应SQLSECR-VVEENCORE字段类型标识类

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

透过添加地方的类,我们今日得以对数据库表展开抽象,用相应的个性标识字段是还是不是为主键,外键或然为虚拟字段,SQL字段于.net类型的转换关系。各Model类之间的连日关系。

DBJoinAttribute类为涉及表连接类型天性标识类

开辟VS二〇一〇,新建一个类库。分别起名为Model,和DAL。

作者在Model类库下添加DbKeyType类,TableJoinType类,DBFieldAttribute类,DBJoinAttribute类,DBTableAttribute类,DBTypeAttribute类。

Model层为数量库表结构涉及映射

字段会有主键,外键标识或然是虚拟字段标识。大家在字段属性上添加自定义性格类DBField来描述他们。

TableJoinType为表连接类型枚举类

咱俩先从Model层起首。

上一篇中简单分享了下OXC90M的布署思路。今后早先讲怎样用代码来兑现上篇的规划模型。

 

 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 }

View Code

起名 7

 

发表评论

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

网站地图xml地图