您的位置:新葡亰496net > 奥门新萄京娱乐场 > 新葡亰496net花色中的web,粤语翻译类别

新葡亰496net花色中的web,粤语翻译类别

发布时间:2019-09-15 20:27编辑:奥门新萄京娱乐场浏览(115)

             最近在做公司的项目,自己负责webapi的框架的搭建与开发,最近很忙,一直没时间对工作中遇到的知识点缺少个总结,现总结一下,对自己是个提升,如果个人的小点点小总结能对博友有帮助那也是善莫大焉.

    项目中的web api知识总结,webapi知识总结

             最近在做公司的项目,自己负责webapi的框架的搭建与开发,最近很忙,一直没时间对工作中遇到的知识点缺少个总结,现总结一下,对自己是个提升,如果个人的小点点小总结能对博友有帮助那也是善莫大焉.

    (1)、 首先说一下c# dynamic,dynamic是FrameWork4.0的新特性.我在api中用了比较多的dynamic,首先个人认为dynamic能使代码变得优雅,可以省去定义多余的实体,dynamic是运行时决定类型有哪些属性,包括赋值和取值都可以随便指定属性,

    例如:

    dynamic sourceInfo = SqlDataHelper.GetWebDMDynamicData(sourceIdSql, new {id=3).FirstOrDefault();
                        if (null != sourceInfo)
                        {
                            item.SourceId = sourceInfo.SourceId;
                            item.DocType = sourceInfo.DocType;
                            item.InvestmentType = sourceInfo.InvestmentType;
                        }
    

    以上代码中sourceInfo指定了dynamic,开发人员知道如果取值成功肯定会有SourceId属性,所以item.SourceId = sourceInfo.SourceId;赋值就不奇怪了.

    同样如下代码也可以自己为dynamic随便指定属性:

    1 dynamic data= null;
    2 data= SqlDataHelper.GetWebDMDynamicData(sql, new { Id = id }).ToList().FirstOrDefault();
    3 data.a= 124;
    4 data.b= "test2";
    5 data.c="test3";
    

    可以为dynamic类型data随便指定属性,前提条件是在第(2)步骤时data的值不能为空,否则在第(3)步data是null,这时候就会出现空异常.

    (2)、再谈论一下轻量级的ORM框架,这个框架网上已经充斥了大量的学习资料,本人只是对项目中的使用心得做些概括,不对之处欢迎指正.

            我们知道调用数据库存储过程肯定有参数化,dapper提供了一个比较好的参数化对象DynamicParameters,上代码:

    DynamicParameters dynamicParameters = new DynamicParameters();
                dynamicParameters.Add("@p_Id1", id1, DbType.String);
                dynamicParameters.Add("@p_Id2", id2, DbType.Int32);
                dynamicParameters.Add("@p_dateTime", dateTime, DbType.DateTime);
                List<dynamic> info =  conn.Query<T>(storeProcedureName,dynamicParameters, null, true, null, CommandType.StoredProcedure) as List<T>;
    

            如果要指定执行存储过程,那么要指定CommandType.StoredProcedure关键字.

     (3)、以下是List<T>转dataTable的方法,的确为类型转换省去了好多的代码,但是也有一个自己花了点时间没有解决的问题,就是T必须指定实体类型,而不能使用dynamic,否则type.GetProperties

    取不到正确的属性,这样系统就必须多定义一个实体类传进来.

     public static DataTable ToDataTable<T>(IList<T> list)
            {
                //create propertyInfo
                List<PropertyInfo> pList = new List<PropertyInfo>();
                //get reflector interface
                Type type = typeof(T);
                DataTable dt = new DataTable();
                //add datatable column
                Array.ForEach<PropertyInfo>(type.GetProperties(), p => { pList.Add(p); dt.Columns.Add(p.Name, Nullable.GetUnderlyingType(
                p.PropertyType) ?? p.PropertyType); });
                foreach (var item in list)
                {
                    //create new row
                    DataRow row = dt.NewRow();
                    pList.ForEach(p => row[p.Name] = p.GetValue(item, null)??System.DBNull.Value);
                    dt.Rows.Add(row);
                }
                return dt;
            }
    

    好了,以上就是项目中的一些小小的总结,还有一些零碎的知识点不做过多描述了.通过项目过程中还有好多要学习的能力,特别是沟通能力,技术引导业务能力.

    api知识总结,webapi知识总结 最近在做公司的项目,自己负责webapi的框架的搭建与开发,最近很忙,一直没时间对工作中遇到的...

    版本记录

    翻译的初衷以及为什么选择《Entity Framework 6 Recipes》来学习,请看本系列开篇

    (1)、 首先说一下c# dynamic,dynamic是FrameWork4.0的新特性.我在api中用了比较多的dynamic,首先个人认为dynamic能使代码变得优雅,可以省去定义多余的实体,dynamic是运行时决定类型有哪些属性,包括赋值和取值都可以随便指定属性,

    版本号 时间
    V1.0 2017.07.29

    3-6在查询中设置默认值

    问题

      你有这样一个用例,当查询返回null值时,给相应属性设置默认值。在我们示例中,当数据库中返回null值时,用‘0’作为YearsWorked属性的默认值。

    解决方案

      假设你有如图3-7所示的模型,你想通过模型查询employees。在数据库中,代表employees的表包含一可为空的YearsWorked列。该列映射到Employee实体中的YearsWorked属性。你想把返加行中包含null值的YearsWorked设置成默认值0。

    新葡亰496net 1

    图3-7 包含一个Employee实体类型的模型,实体类型包含一个EmployeeId属性、一个Name属性和一个YearsWorked属性

     

      示例使用实体框架中的code-first,在代码清单3-11,我们创建了一个Employee类。

    代码清单3-11. Employee 实体类

    1   public class Employee
    2     {
    3         public int EmployeeId { get; set; }
    4         public string Name { get; set; }
    5         public int? YearsWorked { get; set; }
    6     }
    

     接下来,代码清单3-12创建上下文对象

     1  public class EFRecipesEntities : DbContext
     2     {
     3         public EFRecipesEntities()
     4             : base("ConnectionString") {}
     5 
     6         public DbSet<Employee> Employees { get; set; }
     7 
     8         protected override void OnModelCreating(DbModelBuilder modelBuilder)
     9         {
    10             modelBuilder.Entity<Employee>().ToTable("Chapter3.Employee");
    11             base.OnModelCreating(modelBuilder);
    12         }
    13     }
    

    新葡亰496net花色中的web,粤语翻译类别。 

      因为我们使用的是Code-First的方式,所以能以代码清单3-13所示的方式设值默认值。注意,代码清单3-13中的方式不能真正的实现(从数据库中返回)Employee实体类型的实例的默认值。相反,查询的结果是一个匿名类型的集合,当数据库表中YearsWorked列值为null时,匿名类型的属性YearsWorked被以编程的方式设置成0.因此,数据库中相应的列仍然保持null值,但在实体框架的结果集中我们使用0作为它的默认值。记住,代码清单3-13所示的匿名类型,它是一个在运行时,依据new关键字后边大括号内的属性动态创建的类。

    代码清单3-13. 使用LINQ和Entity SQL给Null值填充默认值

     1 using (var context = new EFRecipesEntities())
     2             {
     3                 // 删除之前的测试数据
     4                 context.Database.ExecuteSqlCommand("delete from chapter3.employee");
     5                 // 添加新的测试数据
     6                 context.Employees.Add(new Employee
     7                 {
     8                     Name = "Robin Rosen",
     9                     YearsWorked = 3
    10                 });
    11                 context.Employees.Add(new Employee {Name = "John Hancock"});
    12                 context.SaveChanges();
    13             }
    14 
    15             using (var context = new EFRecipesEntities())
    16             {
    17                 Console.WriteLine("Employees (using LINQ)");
    18                 var employees = from e in context.Employees
    19                                 select new { Name = e.Name, YearsWorked = e.YearsWorked ?? 0 };
    20                 foreach (var employee in employees)
    21                 {
    22                     Console.WriteLine("{0}, years worked: {1}", employee.Name,
    23                         employee.YearsWorked);
    24                 }
    25             }
    26 
    27             using (var context = new EFRecipesEntities())
    28             {
    29                 Console.WriteLine("nEmployees (using ESQL w/named constructor)");
    30                 var esql = @"select value Recipe3_6.Employee(e.EmployeeId, 
    31                       e.Name,
    32                       case when e.YearsWorked is null then 0
    33                            else e.YearsWorked end) 
    34                     from Employees as e";
    35 
    36 
    37                 var employees = ((IObjectContextAdapter) context).ObjectContext.CreateQuery<Employee>(esql);
    38                 foreach (var employee in employees)
    39                 {
    40                     Console.WriteLine("{0}, years worked: {1}", employee.Name,
    41                         employee.YearsWorked.ToString());
    42                 }
    43             }
    44 
    45             Console.WriteLine("nPress <enter> to continue...");
    46             Console.ReadLine();
    

    代码清单3-13的输出如下:

    Employees (using LINQ)
    Robin Rosen, years worked: 3
    John Hancock, years worked: 0
    Employees (using ESQL w/named constructor)
    Robin Rosen, years worked: 3
    John Hancock, years worked: 0
    

     

    原理

      我们在这里使用的方法是,使用LINQ和eSQL将结果投影到一个匿名类型集合,当YearsWorked在底层数据库中为null值时,查询将其设置成0。

      在LINQ方法中,我们使用了C#中的 null值合并(null-coalescing) 操作符??,当YearsWorded在数据库中的值为null时,将0分配给它。我们将结果投影到一个匿名类型集合。

      在Entity SQL方法中,当YearsWorded在数据库中的值为null时,我们使用了case语句来分配0给YearsWorked。我们这里演示了,如何使用Entity SQL,在不设置默认值的情况下,实例化Employee实体类型的实例。为此,我们使用了实体类型的命名构造函数(named  constructor)。这个构造函数,使用实体类型中属性定义的顺序从参数中为属性赋值。在我们示例中,Employee实体的属性定义顺序为:EmployeeId,Name,YearsWorked,从eSQL 查询中传递给构造函数参数的顺序与此一至。不幸的是,在LINQ to Entiytes中没有合适的命名构造函数语法支持。

     

     

    例如:

    前言

    我是swift2.0的时候开始接触的,记得那时候还不是很稳定,公司的项目也都是用oc做的,并不对swift很重视,我自己学了一段时间,到现在swift3.0 已经出来了,自己平时也不写,忘记的也差不多了,正好项目这段时间已经上线了,不是很忙,我就可以每天总结一点了,希望对自己对大家有所帮助。在总结的时候我会对比oc进行说明,有代码的我会给出相关比对代码。
    1. swift简单总结(一)—— 数据简单值和类型转换
    2. swift简单总结(二)—— 简单值和控制流
    新葡亰496net,3. swift简单总结(三)—— 循环控制和函数
    4. swift简单总结(四)—— 函数和类
    5. swift简单总结(五)—— 枚举和结构体
    6. swift简单总结(六)—— 协议扩展与泛型
    7. swift简单总结(七)—— 数据类型
    8. swift简单总结(八)—— 别名、布尔值与元组
    9. swift简单总结(九)—— 可选值和断言
    10. swift简单总结(十)—— 运算符
    11. swift简单总结(十一)—— 字符串和字符
    12. swift简单总结(十二)—— 集合类型之数组
    13. swift简单总结(十三)—— 集合类型之字典
    14. swift简单总结(十四)—— 控制流
    15. swift简单总结(十五)—— 控制转移语句
    16. swift简单总结(十六)—— 函数
    17. swift简单总结(十七)—— 闭包(Closures)
    18. swift简单总结(十八)—— 枚举
    19. swift简单总结(十九)—— 类和结构体
    新葡亰496net花色中的web,粤语翻译类别。20. swift简单总结(二十)—— 属性
    21. swift简单总结(二十一)—— 方法
    22. swift简单总结(二十二)—— 下标脚本
    23. swift简单总结(二十三)—— 继承

    3-7从存储过程中返回多结果集

    问题

      你有一个存储过程,它返回多个结果集。你想从每个结果集实体化到实体实例。

     

    解决方案

      假设你有如图3-8所示的模型和一个代码清单3-14所示的存储过程,存储过程返回job和bid集合。

    新葡亰496net 2

    图3-8 一个代码job和bid的模型

     

     代码清单3-14. 返回多结果集的存储过程

    1 create procedure Chapter3.GetBidDetails
    2 as
    3 begin
    4 select * from Chapter3.Job
    5 select * from Chapter3.Bid
    6 end
    

     

      在我们的模型中,每个job有零个或是多个bids。我们的存储过程返回所有的jobs和bids。我们想执行存储过程并实例化两个结果集中的所有jobs和bids。按代码清单3-15实现此需求。

    代码清单3-15. 从存储过程返回的多结果集实例化Jobs和Bids

     1  using (var context = new EFRecipesEntities())
     2             {
     3                 var job1 = new Job {JobDetails = "Re-surface Parking Log"};
     4                 var job2 = new Job {JobDetails = "Build Driveway"};
     5                 job1.Bids.Add(new Bid {Amount = 948M, Bidder = "ABC Paving"});
     6                 job1.Bids.Add(new Bid {Amount = 1028M, Bidder = "TopCoat Paving"});
     7                 job2.Bids.Add(new Bid {Amount = 502M, Bidder = "Ace Concrete"});
     8                 context.Jobs.Add(job1);
     9                 context.Jobs.Add(job2);
    10                 context.SaveChanges();
    11             }
    12 
    13             using (var context = new EFRecipesEntities())
    14             {
    15                 var cs = @"Data Source=.;Initial Catalog=EFRecipes;Integrated Security=True";
    16                 var conn = new SqlConnection(cs);
    17                 var cmd = conn.CreateCommand();
    18                 cmd.CommandType = System.Data.CommandType.StoredProcedure;
    19                 cmd.CommandText = "Chapter3.GetBidDetails";
    20                 conn.Open();
    21                 var reader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
    22                 var jobs = ((IObjectContextAdapter) context).ObjectContext.Translate<Job>(reader, "Jobs",
    23                     MergeOption.AppendOnly).ToList();
    24                 reader.NextResult();
    25                 ((IObjectContextAdapter) context).ObjectContext.Translate<Bid>(reader, "Bids", MergeOption.AppendOnly)
    26                     .ToList();
    27                 foreach (var job in jobs)
    28                 {
    29                     Console.WriteLine("nJob: {0}", job.JobDetails);
    30                     foreach (var bid in job.Bids)
    31                     {
    32                         Console.WriteLine("tBid: {0} from {1}",
    33                             bid.Amount.ToString(), bid.Bidder);
    34                     }
    35                 }
    36 
    37                 Console.WriteLine("nPress <enter> to continue...");
    38                 Console.ReadLine();
    39             }
    

    代码清单3-15输出如下:

    Job: Re-surface Parking Log
    Bid: $948.00 from ABC Paving
    Bid: $1,028.00 from TopCoat Paving
    Job: Build Driveway
    Bid: $502.00 from Ace Concrete
    

     

    原理

      一开始,我添加了两个jobs和一些与之相对的bids,然后将他们添加到上下文中,最新调用SaveChanges()函数保存至数据库。

      实体框架5.0就已经提供了对存储过程返回多结果集的支持。然后,要使用此功能的话,你得使用遗留的ObjectContext对象,因为最新的DbContext对象对此不提供直接的支持。 为了解决这个问题,我们使用了SqlClient方式来读取存储过程的返回。此模式需要创建SqlConnection,SqlCommand.将存储过程的名称设置成SqlCommand的命令文本,最后调用ExecuteReader()方法得到一个DataReader对象。

      有了reader对象后,我们就可以使用ObjectContext对象中的Translate()方法从reader对象中实例化Job实体。这个方法需要以下三个参数:reader,实体集的名称和一个合并选项。需要实体集名称是因为,一个实体可能存在包含多个实体集的结果集中。实体框架需要知道你想使用哪个实体集。

      合并选项有一些需要注意的地方,我们使用MergeOption.AppendOnly选项,会让实体的实例被添加到上下文对象中并被跟踪。使用这个选项的原因是,让实体框架自动关联jobs和bids。为了实现这个目的,只要简单地把jobs和bids添加到上下文中,实体框架就会帮我们自动关联它们。这为我们省去了大量的冗余代码。

      方法Translate()的另一个简单点的版本,不需要MergeOption. 它将离开上下文对象来实例化对象。这两个版本的方法略有不同,在上下文对象之外创建的对象将不被跟踪。如果你使用这个简单版本的Translate()方法读取jobs,那么你将不能在上下文中实例化一个新的bits。因为实体框架没有任何有关jobs关联对象的引用。这些jobs是在上下文对象之外创建的。另外你不能修改这些实例的属性并期待实体框架帮你保存这些改变。

      我们使用ToList()方法强制枚举每个查询,这是因为Translate()方法返回的是ObjectResult<T>,它不会真正的从reader中读取结果。我需要在使用NextResult()方法处理下一个结果集前,强制从reader中读取结果。在实践中,我们多数会在代码中使用NextResult()方法来继续查找存储过程返回的结果集。

      虽然我们没有在这个示例中见到它,但需要引起注意的是,Translate()方法绕过了映射层模型。如果你想使用继承映射,或者使用一个包含复合类型属性的实体,Translate()方法会失败。Translate()方法需要DbDataReader对象提供与实体属性匹配的列。匹配过程简单地使用名称进行。如果一列名不能与一个属性匹配上,Translate()方法也会失败。

     

     

    实体框架交流QQ群:  458326058,欢迎有兴趣的朋友加入一起交流

    谢谢大家的持续关注,我的博客地址:

     

    dynamic sourceInfo = SqlDataHelper.GetWebDMDynamicData(sourceIdSql, new {id=3).FirstOrDefault();
                        if (null != sourceInfo)
                        {
                            item.SourceId = sourceInfo.SourceId;
                            item.DocType = sourceInfo.DocType;
                            item.InvestmentType = sourceInfo.InvestmentType;
                        }
    

    构造过程 - Initialization

    这里要说一下构造过程,构造过程是为了使用某个类、结构体或者枚举类型的实例而进行的准备过程。这个过程包含了为实例中的每个属性设置初始值和为其执行必要的准备和初始化任务。

    构造过程是通过定义构造器(Initialization)来实现的,这些构造器可以看做是用来创建特定类型实例的特殊方法,swift中的构造器无需返回返回值,它们的主要任务是保证新实例在第一次使用前完成正确的初始化。

    类实例可以通过析构器(deinitializer)在类实例释放之前执行特定的清楚工作。

    这一篇从下面几个方面讲解:

    • 存储型属性的初始值
    • 定制化构造过程
    • 默认构造器
    • 值类型的构造器代理

    以上代码中sourceInfo指定了dynamic,开发人员知道如果取值成功肯定会有SourceId属性,所以item.SourceId = sourceInfo.SourceId;赋值就不奇怪了.

    存储型属性的初始赋值

    类和结构体在实例创建时,必须为所有存储型属性设置合适的初始值,存储型属性的值不能处于一个未知的状态。可以在构造器中为存储型属性赋初值,也可以在定义属性时为其设置默认值。

    注意:为存储型属性设置值时,它们的值时被直接设置的,不会触发任何属性观测器(property observer)

    同样如下代码也可以自己为dynamic随便指定属性:

    1. 构造器

    构造器在创建某特定类型的新实例时调用,它的最简形式类似于一个不带任何参数的实例方法,以关键字init命名。

    下面我们看一个例子。

    class JJPracticeVC: UIViewController {
    
        override func viewDidLoad()
        {
            super.viewDidLoad()
    
            view.backgroundColor = UIColor.lightGray
    
            var f = Fahrenheit()
            print("temperature is (f.temperature)")
        }
    }
    
    struct Fahrenheit {
        var temperature : Double
        init() {
            temperature = 32.0
        }
    }
    

    下面看输出结果

    temperature is 32.0
    

    这个结构体定义了一个不带参数的构造器init,并在里面将存储型属性temperature的值初始化为32.0

    1 dynamic data= null;
    2 data= SqlDataHelper.GetWebDMDynamicData(sql, new { Id = id }).ToList().FirstOrDefault();
    3 data.a= 124;
    4 data.b= "test2";
    5 data.c="test3";
    

    2. 默认属性值

    如果一个属性总是使用同一个初始值,可以为其设置一个默认值,无论定义默认值还是在构造器中赋值,最终它们实现的效果是一样的,只不过默认值将属性的初始化和属性的声明结合的更紧密,使用默认值能让你的构造器更简洁和更清晰。

    你可以使用更简单的方式在定义结构体Fahrenheit时为属性temperature设置默认值,具体如下代码所示。

    struct Fahrenheit {
        var temperature : 32.0
    }
    

    可以为dynamic类型data随便指定属性,前提条件是在第(2)步骤时data的值不能为空,否则在第(3)步data是null,这时候就会出现空异常.

    定制化构造过程

    你可以通过输入参数和可选属性类型来定制构造过程,也可以在构造过程中修改常量属性。

    (2)、再谈论一下轻量级的ORM框架,这个框架网上已经充斥了大量的学习资料,本人只是对项目中的使用心得做些概括,不对之处欢迎指正.

    1. 构造函数

    你可以在定义构造器时提供构造函数,为其提供定制化构造所需值的类型和名字。构造器参数的功能和语法跟函数和方法参数相同。

    下面看一个简单例子。

    class JJPracticeVC: UIViewController {
    
        override func viewDidLoad()
        {
            super.viewDidLoad()
    
            view.backgroundColor = UIColor.lightGray
            let boillingPointOfWater = Celsuis(formFahrenheit: 212.0)
            let freezePointOfWater = Celsuis(fromKelvin: 273.15)
            print(boillingPointOfWater)
            print(freezePointOfWater)
        }
    }
    
    struct Celsuis {
        var temperatureInCelsuis : Double = 0.0
        init(formFahrenheit fahrenheit : Double) {
            temperatureInCelsuis = (fahrenheit - 32.0) / 1.0
        }
    
        init(fromKelvin kelvin : Double) {
            temperatureInCelsuis = kelvin - 273.15
        }
    }
    

    下面我们看结果输出

    Celsuis(temperatureInCelsuis: 180.0)
    Celsuis(temperatureInCelsuis: 0.0)
    

    可以发现,我们可以定义多个构造器,并且可以设置外部参数和内部参数,这里设置的是两个构造器。

            我们知道调用数据库存储过程肯定有参数化,dapper提供了一个比较好的参数化对象DynamicParameters,上代码:

    2. 内部和外部参数名

    其实,这个功能上个例子已经可以看到,在构造器中设置内部参数和外部参数。如果在定义构造器的时候没有提供参数的外部名字,swift会为每个构造器的参数自动生成一个和内部名字相同的外部名,就相当于在每个构造参数之前加一个哈希符号。

    class JJPracticeVC: UIViewController {
    
        override func viewDidLoad()
        {
            super.viewDidLoad()
    
            view.backgroundColor = UIColor.lightGray
    
            let color = Color(red: 1.0, green: 1.0, blue: 1.0)
            print(color.red)
            print(color.green)
            print(color.blue)
        }
    }
    
    struct Color {
        var red = 0.0, green = 0.0, blue = 0.0
        init(red : Double, green : Double, blue : Double) {
            self.red = red
            self.green = green
            self.blue = blue
        }
    }
    

    下面看输出结果

    1.0
    1.0
    1.0
    
    DynamicParameters dynamicParameters = new DynamicParameters();
                dynamicParameters.Add("@p_Id1", id1, DbType.String);
                dynamicParameters.Add("@p_Id2", id2, DbType.Int32);
                dynamicParameters.Add("@p_dateTime", dateTime, DbType.DateTime);
                List<dynamic> info =  conn.Query<T>(storeProcedureName,dynamicParameters, null, true, null, CommandType.StoredProcedure) as List<T>;
    

    3. 可选属性类型

    如果你定制的类型包含一个逻辑上允许取值为空的存储型属性,不管是因为它无法在初始化时赋值,还是因为它可以在之后某个时间点可以赋值为空,你都需要将它定义为可选类型optional type,可选类型的属性将自动初始化为空nil,表示这个属性是故意在初始化时设置为空的。

    看一下下面的例子。

    class JJPracticeVC: UIViewController {
    
        override func viewDidLoad()
        {
            super.viewDidLoad()
    
            view.backgroundColor = UIColor.lightGray
    
            let cheeseQuestion = SurveyQuestion(text: "Do you like me?")
            cheeseQuestion.ask()
            cheeseQuestion.response = "YES, I do!"
            print(cheeseQuestion.response)
        }
    }
    
    class SurveyQuestion{
        var text : String
        var response : String?
        init(text : String) {
            self.text = text
        }
    
        func ask(){
            print(text)
        }
    }
    

    下面看输出结果

    Do you like me?
    Optional("YES, I do!")
    

    这里,response就是可选属性,当SurveyQuestion实例化时,它将自动赋值为空nil,表明暂时不存在此字符串。

            如果要指定执行存储过程,那么要指定CommandType.StoredProcedure关键字.

    4. 构造过程中常量属性的修改

    只要在构造过程结束前常量的值能确定,你可以在构造过程中的任意时间点修改常量属性的值,对某个类实例来说,它的常量属性只能在定义它的类的构造过程中修改,不能再子类中修改,下面看一个例子。

    class SurveyQuestion{
        let text : String
        var response : String?
        init(text : String) {
            self.text = text
        }
    
        func ask(){
            print(text)
        }
    }
    

    这里

     let text : String
    

    定义了常量属性,并且在构造器中进行了修改。


     (3)、以下是List<T>转dataTable的方法,的确为类型转换省去了好多的代码,但是也有一个自己花了点时间没有解决的问题,就是T必须指定实体类型,而不能使用dynamic,否则type.GetProperties

    默认构造器

    swift为所有属性已提供默认值的且自身没有定义任何构造器的结构体或基类,提供一个默认的构造器。下面我们在看一个例子。

    class ShoppingList{
        var name : String?
        var quatity = 1
        var purchased = false
    }
    

    这里ShoppingList的所有属性都有默认值,它将自动获得一个可以为所有属性设置默认值的默认构造器。

    取不到正确的属性,这样系统就必须多定义一个实体类传进来.

    1. 结构体的逐一成员构造器

    如果结构体对所有存储型属性提供了默认值并且自身没有提供定制的构造器,它们能自动获得一个逐一成员构造器。看一下下面的简单例子。

    class JJPracticeVC: UIViewController {
    
        override func viewDidLoad()
        {
            super.viewDidLoad()
    
            view.backgroundColor = UIColor.lightGray
    
            let size = Size(width: 2.0, height: 2.0)
        }
    }
    
    struct Size {
        var width = 0.0, height = 0.0
    }
    

    下面,Size是一个结构体,它包含两个属性widthheight,结构体自动获得一个逐一成员构造器init(width:height),可以为Size创建新的实例。


     public static DataTable ToDataTable<T>(IList<T> list)
            {
                //create propertyInfo
                List<PropertyInfo> pList = new List<PropertyInfo>();
                //get reflector interface
                Type type = typeof(T);
                DataTable dt = new DataTable();
                //add datatable column
                Array.ForEach<PropertyInfo>(type.GetProperties(), p => { pList.Add(p); dt.Columns.Add(p.Name, Nullable.GetUnderlyingType(
                p.PropertyType) ?? p.PropertyType); });
                foreach (var item in list)
                {
                    //create new row
                    DataRow row = dt.NewRow();
                    pList.ForEach(p => row[p.Name] = p.GetValue(item, null)??System.DBNull.Value);
                    dt.Rows.Add(row);
                }
                return dt;
            }
    

    值类型的构造器代理

    构造器可以通过调用其他构造器来完成实例的部分构造过程,这一过程成为构造器代理,它能减少多个构造器间的代码重复。

    构造器代理的实现规则和形式在值类型和类类型中有所不同,值类型(结构体和枚举)不支持继承,所以构造器代理的过程相对简单,因为它们只能代理给本身提供的其他构造器,类则不同,它可以继承自其他类,这意味着类有责任保证其所有继承的存储型属性在构造时也能正确的初始化。

    对于值类型,你可以使用self.init在自定义的构造器中引用其他的属于相同值类型的构造器,并且你只能在构造器内部使用self.init在。

    注意:如果你为某个值类型定义了一个定制构造器,你将无法访问到默认构造器(如果是结构体,则无法访问注意对象构造器),防止定义了定制的构造器,别人还是错误的使用自动生成的构造器。

    下面看一个例子。

    struct Size {
        var width = 0.0, height = 0.0
    }
    
    struct Point {
        var x = 0.0, y = 0.0
    }
    
    struct Rect {
        var origin = Point()
        var size = Size()
        init() {
    
        }
    
        init(origin : Point, size : Size) {
            self.origin = origin
            self.size = size
        }
    
        init(center : Point, size : Size) {
            let originX = center.x - size.width * 0.5
            let originY = center.y - size.height * 0.5
            self.init(origin: Point(x : originX, y : originY), size: size)
        }
    }
    

    这里用到了三个构造器,如下:

    • 第一个构造器init(),在功能上根没有自定义构造器时自动获得的默认构造器是一样的,大括号里什么都没做,调用这个构造器就会返回一个Rect实例,它的originsize属性都使用自定义的默认值Point(x = 0.0, y = 0.0)和Size (width = 0.0, height = 0.0)

    下面我们调用一下

    class JJPracticeVC: UIViewController {
    
        override func viewDidLoad()
        {
            super.viewDidLoad()
    
            view.backgroundColor = UIColor.lightGray
    
            let basicRect = Rect()
            print(basicRect.origin)
            print(basicRect.size)
        }
    }
    

    下面看输出结果

    Point(x: 0.0, y: 0.0)
    Size(width: 0.0, height: 0.0)
    
    • 第二个Rect构造器init(origin : size : ),在功能上跟结构体在没有自定义构造器时获得的逐一成员构造器是一样的,这个构造器只是简单的将originsize参数值赋值给对应的存储型属性。

    下面我们调用一下。

    class JJPracticeVC: UIViewController {
    
        override func viewDidLoad()
        {
            super.viewDidLoad()
    
            view.backgroundColor = UIColor.lightGray
    
            let originRect = Rect(origin: Point(x : 2.0, y : 2.0), size : Size(width: 5.0, height: 5.0))
            print(originRect.origin)
            print(originRect.size)
    
        }
    }
    

    下面看输出结果

    Point(x: 2.0, y: 2.0)
    Size(width: 5.0, height: 5.0)
    
    • 第三个Rect构造器init(center : size :),这个复杂一点,先通过centersize计算origin坐标,然后调用或代理给init(origin : size : )构造器构造出新的originsize

    下面我们调用一下。

    class JJPracticeVC: UIViewController {
    
        override func viewDidLoad()
        {
            super.viewDidLoad()
    
            view.backgroundColor = UIColor.lightGray
    
            let centerRect = Rect(center: Point(x : 4.0, y : 4.0), size: Size(width: 3.0, height: 3.0))
            print(centerRect.origin)
            print(centerRect.size)
        }
    }
    

    下面看一下输出结果

    Point(x: 2.5, y: 2.5)
    Size(width: 3.0, height: 3.0)
    

    好了,以上就是项目中的一些小小的总结,还有一些零碎的知识点不做过多描述了.通过项目过程中还有好多要学习的能力,特别是沟通能力,技术引导业务能力.

    后记

    未完,待续~~~

    新葡亰496net 3

    本文由新葡亰496net发布于奥门新萄京娱乐场,转载请注明出处:新葡亰496net花色中的web,粤语翻译类别

    关键词: