2023年2月

随笔背景
:在很多时候,很多入门不久的朋友都会问我:我是从其他语言转到C#开发的,有没有一些基础性的资料给我们学习学习呢,你的框架感觉一下太大了,希望有个循序渐进的教程或者视频来学习就好了。

其实也许我们每天面对的太多东西了,觉得很多都稀松平常了,即使很细微的地方,可能我们都已经形成习惯了。反过来,如果我们切换到其他领域,如IOS、android,那么开始我们可能对里面很多设计的规则不甚了解,开始可能也是一头雾水。

本篇继续上一篇《
循序渐进开发WinForm项目(4)--Winform界面模块的集成使用
》,继续介绍如何循序渐进开发Winform项目,介绍业务模块常见的导入导出操作的功能实现,使得我们能够快速,高效开发常见的模块功能。

上篇随笔我们介绍到自动代码生成的界面如下所示,具备了导入、导出操作,这个操作是针对Excel进行的。

下面我们来介绍这个在很多模块里面常见的Excel导入、Excel导出操作是如何实现的。

1、Excel数据的导出操作

由于我为了演示的目的,我在客户信息表里面只是设计了几个代表性的字段,下面我们来看看代码生成工具自动生成的界面后台代码是如何的。

        /// <summary>
        ///导出Excel的操作/// </summary>
        private void btnExport_Click(objectsender, EventArgs e)
{
string file = FileDialogHelper.SaveExcel(string.Format("{0}.xls", moduleName));if (!string.IsNullOrEmpty(file))
{
string where =GetConditionSql();
List
<CustomerInfo> list = BLLFactory<Customer>.Instance.Find(where);
DataTable dtNew
= DataTableHelper.CreateTable("序号|int,姓名,年龄,创建人,创建时间");
DataRow dr;
int j = 1;for (int i = 0; i < list.Count; i++)
{
dr
=dtNew.NewRow();
dr[
"序号"] = j++;
dr[
"姓名"] =list[i].Name;
dr[
"年龄"] =list[i].Age;
dr[
"创建人"] =list[i].Creator;
dr[
"创建时间"] =list[i].CreateTime;
dtNew.Rows.Add(dr);
}
try{string error = "";
AsposeExcelTools.DataTableToExcel2(dtNew, file,
outerror);if (!string.IsNullOrEmpty(error))
{
MessageDxUtil.ShowError(
string.Format("导出Excel出现错误:{0}", error));
}
else{if (MessageDxUtil.ShowYesNoAndTips("导出成功,是否打开文件?") ==System.Windows.Forms.DialogResult.Yes)
{
System.Diagnostics.Process.Start(file);
}
}
}
catch(Exception ex)
{
LogTextHelper.Error(ex);
MessageDxUtil.ShowError(ex.Message);
}
}
}

上面的代码中,
FileDialogHelper.SaveExcel
函数
是调用公用类库模块,弹出一个选择保存文件的对话框,如果你没有这个类,你可以自己添加代码实现这个操作(这就是公用类库的好处,在使用的时候能够快速调用,减少代码,提高效率)。

然后根据客户录入的条件检索需要的数据内容:
string where = GetConditionSql()
;

接着就是构建一个相关字段的表格对象:
DataTableHelper.CreateTable
,这里面也是使用公用类库来方便创建各种字段的表格,默认字段为字符串格式,如果需要如整形格式的,可以通过|进行分割,如“序号|int” 。

创建DataTable对象后,我们遍历对象集合,把它里面的数据一行行的赋值给DataRow对象就可以了。

                for (int i = 0; i < list.Count; i++)
{
dr
=dtNew.NewRow();
dr[
"序号"] = j++;
dr[
"姓名"] =list[i].Name;
dr[
"年龄"] =list[i].Age;
dr[
"创建人"] =list[i].Creator;
dr[
"创建时间"] =list[i].CreateTime;
dtNew.Rows.Add(dr);
}

赋值后,就是需要把DataTable对象转换为Excel的操作过程了,这里操作分为两步,第一是创建Excel文档,第二个是写数据的表头和数据行信息,也就是数据的写入操作,这里面我们把它封装在公用类库里面,方便模块之间的调用。

导出Excel模块采用了基于Aspose.Cell的组件进行数据的写入操作:
AsposeExcelTools.DataTableToExcel2

导出完成后,我们提示用户是否打开Excel文件。

if (MessageDxUtil.ShowYesNoAndTips("导出成功,是否打开文件?") ==System.Windows.Forms.DialogResult.Yes)
{
System.Diagnostics.Process.Start(file);
}

最终,完成功能后,我们运行程序,导出Excel数据的效果如下所示。

2、Excel数据的导入操作

相对于数据的导出操作,Excel数据的导入操作会稍微麻烦一点,你至少需要选择一个文件,文件最好以固定的模板进行导入,因此为了让用户确认数据的有效性,我们最好能提供了一个把Excel数据显示出来再确认导入的过程,这样可以减少导入错误数据的可能。

我们知道,这种常见的导入操作,很多业务模块可能都需要,因此有必要考虑把它抽象出来,作为一个通用的导入模块,这样我们可以多次利用,非常方便,因此我们提炼这个通用导入的模块特性如下所示。

Excel数据的导入模块,默认生成界面的时候,也已经一并生成了,我们来看看其中的代码。

        private string moduleName = "客户信息";/// <summary>
        ///导入Excel的操作/// </summary>          
        private void btnImport_Click(objectsender, EventArgs e)
{
string templateFile = string.Format("{0}-模板.xls", moduleName);
FrmImportExcelData dlg
= newFrmImportExcelData();
dlg.SetTemplate(templateFile, System.IO.Path.Combine(Application.StartupPath, templateFile));
dlg.OnDataSave
+= newFrmImportExcelData.SaveDataHandler(ExcelData_OnDataSave);
dlg.OnRefreshData
+= newEventHandler(ExcelData_OnRefreshData);
dlg.ShowDialog();
}

其中FrmImportExcelData 是一个界面基础模块中定义的一个通用导入模块,里面实现了一些如显示Excel数据,模板信息关联,保存数据的接口等操作。我们来看看它的程序运行的效果。

其中我们通过代码
dlg.SetTemplate
指定模板就是用来关联Excel模板信息的,我们让可以尽可能的选择正确的模板进行录入数据。

用户通过第2的标识,指定要导入的Excel数据文件,选择文件后,数据会自动显示出来方便确认。

但我们选择保存数据的操作的时候,这个通用模块会执行保存的逻辑代码,并调用由创建者实现的代码逻辑,如上面代码的dlg.OnDataSave就是在执行保存的时候,执行的代码逻辑,我们来看看生成的一些代码实现。

        boolExcelData_OnDataSave(DataRow dr)
{
bool success = false;bool converted = false;
DateTime dtDefault
= Convert.ToDateTime("1900-01-01");
DateTime dt;
CustomerInfo info
= newCustomerInfo();
info.Name
= dr["姓名"].ToString();
info.Age
= dr["年龄"].ToString().ToInt32();
info.Creator
= dr["创建人"].ToString();
converted
= DateTime.TryParse(dr["创建时间"].ToString(), outdt);if (converted && dt >dtDefault)
{
info.CreateTime
=dt;
}

success
= BLLFactory<Customer>.Instance.Insert(info);returnsuccess;
}

我们知道,导入的时候,是遍历每行Excel进行数据保存操作的,因此我们这里给出了一个一行的操作代码即可:bool ExcelData_OnDataSave(DataRow dr),里面的逻辑,在数据保存的时候会被模块进行调用。

上面的操作,是一条条的进行操作,如果累计超过3条记录出错,模块提示是否继续还是退出。

这里面并没有采用事务的操作,对于一些如Sqlite的大批量的数据操作(速度提升很快),建议采用事务进行处理,关于这个可以参考《
Winform开发框架之通用数据导入导出操作的事务性操作完善
》进行修改调整。

最后,我们的Excel数据导入完成后,为了及时更新主界面的数据,我们也定义了一个事件作为回调,如下所示。

dlg.OnRefreshData += new EventHandler(ExcelData_OnRefreshData);

这个事件的实现代码就是在主界面的数据绑定更新。

        void ExcelData_OnRefreshData(objectsender, EventArgs e)
{
BindData();
}

循序渐进开发WInform项目--系列文章导引:


循序渐进开发WinForm项目(5)--Excel数据的导入导出操作


循序渐进开发WinForm项目(4)--Winform界面模块的集成使用


循序渐进开发WinForm项目(3)--Winform界面层的项目设计


循序渐进开发WinForm项目(2)--项目代码的分析


循序渐进开发WinForm项目(1) --数据库设计和项目框架的生成

1、Winform数据访问模式定义

传统的Winform程序模块:
用于传统的数据库通讯获取数据,这种方式获取数据,方便快捷,可以用于常规的业务系统的场景,用于单机版软件或者基于局域网内的业务系统软件。

WCF的Winform程序模块:
采用了WCF技术的分布式开发模式,系统能够通过远程的WCF服务获取数据,而不用直接和数据库相连,提高数据的安全性和可维护性,适用于互联网、局域网环境下的业务系统的搭建,是一种稳定、安全的框架应用。

混合式Winform程序模块:
是指混合了传统数据访问和WCF数据访问的特点,可以在两者之间自由切换,统一了系统界面层对业务服务的调用模式,所有组件模块均实现两种方式的调用,是一种弹性化非常好的框架应用,既可用于单机版软件或者基于局域网内的应用软件,也可以用于分布式技术的互联网环境应用。

每种技术都有其存在的合理性,对于混合式的Winform程序而言,也是一样。在数据越发集中的今天,单机版的数据很难进行共享,只在一定范围内进行使用;混合式的Winform程序,结合了Winform程序丰富的体验和强大的功能外,还整合了B/S的这种分布式特点,因此这种模式的存在生命力很强,有一些程序的操作使用Winform方式能够给客户提供非常好的界面效果体验。

2、混合式框架的原理

混合式框架,结合了普通Winform方式和WCF访问数据的分布式框架,因此他们是基于一个跳转开关进行指定,如下示意图所示。

为了适应模块化的特点,所有使用混合式框架的业务模块,除了一个启动的主程序模块外,其他的都是一个个独立的模块,这样方便我们业务横向的划分,可以使大家按照统一模式进行开发,然后再进行统一集成,这种模式可以有效提高开发效率,并且能够使得模块能够反复使用,组合出更多更强的业务系统模块。

下面是一个字典模块的内部设计图,我们可以看到,整个混合式的架构,分为了UI层、接口调用层、Facade接口层、Winform调用层、WCF服务调用层、业务层、实体层、以及数据库层等;其中的业务层还可以细化为BLL业务逻辑层、数据接口层、数据访问层、实体层等,整个模块通过实体层进行数据的传输载体。

3、混合式模块的项目结构

混合型框架把业务系统的WCF服务和辅助性公用模块的WCF服务分开,首先是服务分开,然后是客户端配置文件分开。

下面是一个实际业务系统的WCF服务的截图,可以看出里面的主业务服务和基础服务模块的服务层是分开的,这样方便管理,不至于太多太乱。

WCF服务的客户端配置文件是分开管理的,基础服务和业务服务的配置信息分别用不同的文件表示,如基础模块服务的WCF配置文件为
BaseWcfConfig
.config,业务系统的WCF配置文件为
WcfConfig
.config,通过这样的分离设置,我们在主配置文件app.Config文件里面,就清爽很多了。

    <!--WCF服务的配置文件地址-->
    <addkey="BaseWcfConfig"value="BaseWcfConfig.config"/>
    <addkey="WcfConfig"value="WcfConfig.config"/>

4、开发使用混合式Winform模块

例如,我们在业务逻辑层里面增加一个方法,根据客户名称获取客户列表,如下所示。

namespaceWHC.TestProject.BLL
{
/// <summary> ///客户信息/// </summary> public class Customer : BaseBLL<CustomerInfo>{public Customer() : base()
{
base.Init(this.GetType().FullName, System.Reflection.Assembly.GetExecutingAssembly().GetName().Name);
}
/// <summary> ///根据客户名称获取客户列表/// </summary> /// <param name="name">客户名称</param> /// <returns></returns> public List<CustomerInfo> FindByName(stringname)
{
string condition = string.Format("Name like '%{0}%'", name);returnbaseDal.Find(condition);
}
}
}

图上红色部分的函数是我们新增的内容,完成这个函数,我们来看看完成整个混合式框架,需要增加哪些东西。

1)添加Facade接口

为了统一的接口调用需要,需要先定义Facade层的接口,这是一切的开始。

namespaceWHC.TestProject.Facade
{
[ServiceContract]
public interface ICustomerService : IBaseService<CustomerInfo>{/// <summary> ///根据客户名称获取客户列表/// </summary> /// <param name="name">客户名称</param> /// <returns></returns> [ServiceContract]
List
<CustomerInfo> FindByName(stringname);
}
}

2)增加Winform接口调用层实现

基于Winform的实现,就是根据接口封装对业务逻辑层BLL的调用,BaseLocalService基类,可以看成是具有常规增删改查等等的基础性API,是基于泛型的强类型接口基类。

namespaceWHC.TestProject.WinformCaller
{
/// <summary> ///基于传统Winform方式,直接访问本地数据库的Facade接口实现类/// </summary> public class CustomerCaller : BaseLocalService<CustomerInfo>, ICustomerService
{
private Customer bll = null;public CustomerCaller() : base(BLLFactory<Customer>.Instance)
{
bll
= baseBLL asCustomer;
}
/// <summary> ///根据客户名称获取客户列表/// </summary> /// <param name="name">客户名称</param> /// <returns></returns> public List<CustomerInfo> FindByName(stringname)
{
returnbll.FindByName(name);
}
}
}

3)增加WCF的接口调用层实现

基于WCF的实现,就是根据接口封装对WCF服务层的调用,BaseWCFService基类,可以看成是具有常规增删改查等等的基础性API,是基于泛型的强类型接口基类。

namespaceWHC.TestProject.ServiceCaller
{
/// <summary> ///基于WCF服务的Facade接口实现类/// </summary> public class CustomerCaller : BaseWCFService<CustomerInfo>, ICustomerService
{
public CustomerCaller() : base()
{
this.configurationPath = EndPointConfig.WcfConfig; //WCF配置文件 this.endpointConfigurationName =EndPointConfig.CustomerService;
}
/// <summary> ///子类构造一个IChannel对象转换为基类接口,方便给基类进行调用通用的API/// </summary> /// <returns></returns> protected override IBaseService<CustomerInfo>CreateClient()
{
returnCreateSubClient();
}
/// <summary> ///创建一个强类型接口对象,供本地调用/// </summary> /// <returns></returns> privateICustomerService CreateSubClient()
{
CustomClientChannel
<ICustomerService> factory = new CustomClientChannel<ICustomerService>(endpointConfigurationName, configurationPath);returnfactory.CreateChannel();
}
/// <summary> ///根据客户名称获取客户列表/// </summary> /// <param name="name">客户名称</param> /// <returns></returns> public List<CustomerInfo> FindByName(stringname)
{
List
<CustomerInfo> result = new List<CustomerInfo>();

ICustomerService service
=CreateSubClient();
ICommunicationObject comm
= service asICommunicationObject;
comm.Using(client
=>{
result
=service.FindByName(name);
});
returnresult;
}
}
}

由于WCF的接口封装层相对内容比较复杂一些,这里介绍一下。

构造函数通过代码指定具体的配置文件:this.configurationPath = EndPointConfig.WcfConfig; //WCF配置文件

并通过代码指定具体的WCFEndPoint节点名称:this.endpointConfigurationName = EndPointConfig.CustomerService;

构造WCF服务的代理类,我们通过CustomClientChannel的辅助方法,传入配置文件和配置节点名称,使得它能顺利通过函数
CreateSubClient
构造出一个对应类型的WCF代理类。

            CustomClientChannel<ICustomerService> factory = new CustomClientChannel<ICustomerService>(endpointConfigurationName, configurationPath);return factory.CreateChannel();

每次调用WCF服务类接口的时候,我们就使用创建的代理类进行调用,调用操作如下所示。

ICustomerService service =CreateSubClient();
ICommunicationObject comm
= service as ICommunicationObject;
comm.Using(client =>
{
result = service.FindByName(name);
});

4)增加WCF服务逻辑层的实现

我们通过上面的代码可以了解到,已经创建了Winform的调用层、WCF服务的调用层,但是这里,我们对WCF服务还没有实现,这样我们就需要实现WCF服务层的内容了,否则程序试用WCF方式访问的时候,就找不到这个FindByName的接口实现了。

我们看看WCF服务层里面,看看具体如何实现,双击打开里面的CustomerService.Svc看到只是一个服务的声明,没有任何背后的代码逻辑。

因为为了便于管理,WCF服务一般是定义和具体的实现是分开的,这样就引入了一个WCF服务逻辑层的概念。

这样它的接口实现,就放在了WHC.TestProject.WCFLibrary项目里面了,WCF服务逻辑层的接口调用封装如下所示。这里我们看到,他和Winform的调用逻辑几乎一样,只是他们的类名称不同而已。

namespaceWHC.TestProject.WCFLibrary
{
/// <summary> ///基于WCFLibrary的Customer对象调用类/// </summary> public class CustomerService : BaseLocalService<CustomerInfo>, ICustomerService
{
private Customer bll = null;public CustomerService() : base(BLLFactory<Customer>.Instance)
{
bll
= baseBLL asCustomer;
}
/// <summary> ///根据客户名称获取客户列表/// </summary> /// <param name="name">客户名称</param> /// <returns></returns> public List<CustomerInfo> FindByName(stringname)
{
returnbll.FindByName(name);
}
}
}

5)界面层的调用操作

界面层的调用操作代码如下所示。

string name = ""List<CustomerInfo> list= CallerFactory<ICustomerService>.Instance.FindByName(name)

这个操作模式,和普通使用BLLFactory的方式非常相似的。

5、混合式框架的业务模块组成

混合型框架可以看成是Winform框架高级版本,除了它本身是一个完整的业务系统外,它外围的所有辅助性模块均(如通用权限、通用字典、通用附件管理、通用人员管理。。。。)都实现了这种混合型的框架,因此使用非常方便,整个框架如果简化来看,就是在原有的Winform界面层,用接口调用方式,避免和业务逻辑类的紧耦合关系。由于他是通过接口方式的调用方式,它本身又可以通过配置指定指向WCF的实现,因此也囊括了WCF框架的一切特点。

虽然整体性的混合型框架比其他两种框架模块,总体增加了一些难度及复杂性,不过,为了使得整个混合型框架开发和使用更加方便,我已经在设计上做了很多相关的工作,力求更好、更高效的使用好这种混合型框架,下面是我对整体性的框架做了的优化改进工作。

1)把所有通用的模块开发好,方便更好的集成使用,更加高效利用通用模块,重复利用度更高;

2)把WCF服务发布和服务逻辑分开,更好管理和发布WCF服务,服务发布只需要svc文件,不含任何后台代码;

3)统一的业务调用规则和命名规则,所有模块的接口调用统一为CallerFactory<I***Service>方式,通用模块和框架的命名规则和机制完全一样。

4)WCF服务配置文件分离,通用性的辅助模块的配置文件为BaseWcfConfig.config,业务系统的WCF配置文件为WcfConfig.config,配置文件分离更方便管理和维护,减少主配置文件app.Config的复杂性。

5)最后一条,也是最重要的一条,就是代码生成工具Database2Sharp的同步支持。通过代码生成工具,更好、更快的生成整个混合性框架的代码和项目工程,一键解决所有的烦恼。Winform界面,利用代码生成工具Database2Sharp进行生成,然后在项目中整合即可。

循序渐进开发WInform项目--系列文章导引:


循序渐进开发WinForm项目(5)--Excel数据的导入导出操作


循序渐进开发WinForm项目(4)--Winform界面模块的集成使用


循序渐进开发WinForm项目(3)--Winform界面层的项目设计


循序渐进开发WinForm项目(2)--项目代码的分析


循序渐进开发WinForm项目(1) --数据库设计和项目框架的生成

本随笔系列主要介绍从一个Windows平台从事C#开发到Mac平台苹果开发的一系列感想和体验历程,本系列文章是在起步阶段逐步积累的,希望带给大家更好,更真实的转换历程体验,因为一旦方方面面都精通了,也就可能没太大的动力继续写这系列的文章了,文章中可能有一些地方说的不对或者不够完善的地方,希望大家多多指正,共同提高。

由于本人起步
Objective-C
的苹果开发比较晚,但是因为自己有着比较深厚的C#开发背景,因此在很多方面都会和我之前的经验做比较,因此本系列文章对于从C#转向
Objective-C
的苹果开发来说,应该是比较合适的。

开始介绍这些系列内容之前,花上一些时间做一些自己的背景介绍,希望大家了解起步的背景和我自己的一些感想,以期达到相互共鸣,加深体会。

1、个人技术背景

从事C#语言的开发超过10年了,虽然期间也用过微软的其他语言,如VB6、VB.NET做过开发等,不过都是一段段小插曲,最终还是主要使用C#做开发,包括Winform的开发、Web上面的开发(Webform、JQuery、MVC等),在这方便也有自己的一些见解及较多的积累,包括自己的《Winform开发框架》、《Web开发框架》、《WCF开发框架》、《混合式开发框架》等以及一些其他应用程序,如较早期开发的送水管理系统、酒店管理系统、仓库管理系统,以及后来开发的很多应用程序,如病人资料管理系统、客户关系管理系统等等,还有很多其他基于QQ开发、邮件处理、赶集网数据采集、Visio二次开发、Socket网络通讯、硬件串口的开发方面都有所涉及,基本上这么多年来,把认为重要和感兴趣的.NET技术都学习了一把。有一些技术和产品的积累,也算对得起这么多年来的技术研究了。

书籍撰写方面,早期也就参加过,年轻力壮的时候,生活拮据的年代,ASP技术和ASP.NET技术盛起的时候,分别写过一本《ASP与网站开发实战》和《ASP.NET与网站开发实践教程》,写书的辛苦和出版商的奸诈,从中可以深刻体会到。

俗话说,技不压身,很早就开始想转入苹果开发的系列了,最初从购买自己的Iphone4s开始,就有这个念头,那时候还很早,刚刚2012年初发布的时候就入手一台,同年花钱弄了一个IMAC,一直用不习惯,不过好在安静、方便、大屏幕,偶尔用来晚上玩玩,白天工作不用。

2、苹果平台的转换

苹果桌面操作系统的使用习惯和Windows很不同,你可能习惯在WIndows里面使用Ctrl,而Mac系统主要用Command键替代,虽然键盘也有control键,但是意义完全不同,传统的Windows的Shift按键在Mac系统里也用Option键替代。最开始默认的苹果鼠标还没有右键功能,用了好久才发现,可以启用右键菜单功能,甚至滚轮的方向都有所不同。总之,用惯了Windows平台,你使用Mac系统,会有一个适应的过程。

使用苹果的Mac系统,你也可以使用Windows传统的大键盘,不过建议还是选择较贵的苹果小键盘,虽然不太习惯按键太小,但是很多快捷功能,你在Windows键盘里是不起作用的,这个非常不方便,反正选择配套就对了,呵呵。

苹果的系统,很多功能都在菜单里面寻找,在我们开发之前,最好把基本的系统应用都熟悉一下,一个对这个系统有个了解,二个对苹果的各种操作有一个详细的概念,否则你还不知道文件如何管理呢。

我的操作系统原来装的是猎豹系列的,也安装了XCode开发工具了,前阵子想入手开发的时候,把系统升级到最新,也把XCode更新到了5.02,这个整体系列的更新文件有点大,基本上下载了一天的时间,安装倒是很快,但是可能偶尔会因为网速的原因,断掉,需要接着下载更新。

如果下载多次还是不能成功更新操作系统或者XCode,建议可以通过Mac系统的迅雷下载软件,里面有一个 Thunder Store,速度蛮快了,哈哈。

另外,在开发前,最好能够准备几个IOS设备,IPAD、IPhone都最好有,呵呵。由于XCode5已经不支持进行IOS6以下的版本调试了,因此我把自己的4S从5.1升级到了7.06,虽然新IOS7系统的界面不太习惯,不过为了开发方便,还是升级最好了。

3、注册开发者账号及设置

很早就知道注册苹果开发者账号,每年需要缴纳99美元,这个时候使用信用卡来处理就很好,支持美元支付的就可以了,我使用招行信用卡,周末的时候申请的,好像第二第三天就搞定了,响应的速度还是很快的。

注册开发者账号与否,你都可以使用XCode进行程序开发,但是你开发的应用只能在模拟器中测试,不能在真机测试并发布,而且他们网站还有一些资源使用的限制,不过开始之前可以先熟悉整个开发的流程和知识,如果确定需要从事开发,注册购买一个开发者资格还是非常必要的。

以上红色部分是在苹果开发网站里最为重要的部分了。这里面涉及需要下载开发的证书,以及你需要调试的开发配备证书等。

通过一系列的设置和引导,你可能最终弄好了两个证书,一个是开发的证书,一个是发布的证书,你需要把它们保存并安装到你的Mac电脑上。

申请好后,打开其中的开发证书,看到有下载的链接按钮。

把他下载到本地,然后把它安装到本地的钥匙串里面即可。

弄好了这些后,你需要申请一个Provisioning Profile的开发证书,然后在XCode的【WIndow】【Organizer】里面把你要开发设备接入进来,因为苹果严格规定,只有安装了这个证书的IOS设备,才能用来真机调试,否则是不允许的,因此这些证书的作用就是标识设备是你的,能够用于开发调试。最好为了方便,把所有的IOS设备都接入进来了,截个图大家了解下。

最后,运行XCode的程序,自己创建或者打开一个Demo程序,大致了解下其界面布局吧(默认没有黑色背景的,我通过设置把它调整了以下,感觉眼睛舒服了很多。

4、相关知识的了解

要了解整个IOS开发的系列内容,当然需要全方位的知识掌握,在开发之前,我自己通过网上了解了很多
Objective-C
的基础知识,好像51CTO里面的系列文章还不错。看了不少,逐渐对这个语言也有所了解。

相对于电子书籍,传统的书籍也是很有必要的,因此,我自己也通过了图书馆借了一些书籍帮助了解,借助各种知识的加强学习,能够对XCode的使用和
Objective-C
的语法等使用有一个非常好的熟悉了解。如下面就是我自己从图书馆第一次接回来的书籍。

不过,对于全面了解
Objective-C
等的内容,我后来发现苹果开发平台里面的内容更是全面,虽然全部是英文的,但是看起来非常舒服,叙述的很流畅,关键一点,是苹果把最新最好的特点都叙述的很清晰了,这个比起其他书籍介绍的内容,更加好。

否则你如果看各种参差不齐的书籍,可能对很多地方都有疑问,如有些书籍或者网上的文章,还是在ARC的引入之前的,大量介绍retain release等内容,而Release在引入ARC后,已经不需要写了,引用计数交给编译器完成了。

如在苹果开发网站里面,有一些序列的文章很不错,我自己倒是花了一整天的时间把它学习了一遍,感觉介绍的非常清晰,内容都是苹果根据最新的特性进行更新的,这点非常棒。

Start Developing iOS Apps Today

Programming with Objective-C

iOS App Programming Guide

好了,下一篇继续介绍IOS开发的相关的内容,主要介绍C#和
Objective-C
的一些相同和不同的地方,把他们做一些对比,以便加深学习印象。

本随笔系列主要介绍从一个Windows平台从事C#开发到Mac平台开发苹果开发的一系列感想和体验历程,本系列文章是在起步阶段逐步积累的,希望带给大家更好,更真实的转换历程体验。

在上篇《
从C#到
Objective-C
,循序渐进学习苹果开发(1)--准备开发账号和开发环境

》介绍了一些基本的转换感悟和一些基础的准备工作,还没有正式真实的介绍Objective-C和C#的之前差异,我们知道,从一种环境或者一种语言转换过去另外一种,我们都会做一些对比和理解,这样可以很容易把我们头脑的知识进行对接,在这个所有东西日益大同的背景下,我们相信,所有的语言特点都是相通的。

1、面向对象的类

1)类的定义

Objective-C(下称OC)和C#都是面向对象的语言,虽然OC比C#古老,起源自C,但是很多特点和C#都很接近了,在C#3.0里面才引入的扩展方法,在OC里面也存在了。

OC和C#都一样,他们继承的关系都是单继承的,没有C++的那种多重继承那么复杂,OC很有特点的一个要求就是把接口和实现完全分开,这点是熟悉C#开发的人员必须转换过来的思路,在OC里面,写一个类,先写接口定义,然后再写实现,它的语法和C#很大不同,但是也很容易理解。

OC的关键字一般都是以@符号进行标识,这点和C#的默认保留关键字不同,一般看到@interface, @property, @关键字,在最新版本的XCode里面,真是发挥到了极致了,包含了很多语法糖,基本上和C#走向了大同,这点在对象的初始化继续介绍。

OC的类定义放到.h文件里面,实现放到了.m文件里面,如下面是类的接口声明。

@interfaceSimpleClass : NSObject@end

而类的实现操作如下所示。

#import "SimpleClass.h"
 
@implementationSimpleClass@end

上面只是一个演示类的概念,一般情况下,类都有属性或者方法,因此还需要增加很多东西。

另外OC和C#对比,没有了命名空间的概念,OC的类为了避免混淆一般通过前缀进行区分,如你看到的IOS基础类库,很多带有NS,UI,CA,等这样的前缀,就是这个原因。

2)方法的定义

如下面的接口声明一个方法,方法的定义

@interfaceXYZPerson : NSObject- (void)sayHello;@end

我们看到,上面的方法定义(接口定义)很简单,这里有一个 - 符号,是用来标识属于实例方法的,还有一种属于类级别的方法,用+符号标识,这个加号,类似于C#语言里面的static关键字,默认在方法定义为-的实例方法,都是类似于C#里面的public方法了。

这个(void)定义是返回值的标识,C#是不需要括号的void标识无返回值,方法最后需要括号标识。

- (
void
)sayHello;

这个方法的定义没有参数因此是这样写的,如果方法有多个参数,这个OC就很有意思,我感觉这个是OC里面最有个性的一个地方了。

如果方法如下所示:

- (void)
setCaption
: (NSString*)input;

类方法的调用是通过空格,而C#通过点进行调用,这点也有所不同,OC通过在一个[]里面空格进行引用,如下所示。

[objectmethod];
[
object methodWithInput:input];

刚才定义的sayHello方法,它的调用可能就是如下方式了

[self setCaption:@"Default Caption"];

如果方法的定义为多个参数(也叫多重参数),定义如下。

-(void) setNumerator: (int) n andDenominator: (int) d;

那么方法的调用就很有意思了。

[frac2 setNumerator: 1 andDenominator: 5];

如果还有更多的参数,那么也就一直使用这样的累加方式,这个有点接近阅读习惯,呵呵。

3)参数的定义

说完方法的定义和使用,我们介绍下类里面的属性的定义,我们知道C#里面的属性定义很简单了,如

public string Name {get;set;}

回来看看OC如何定义属性的,一般在.h的接口定义里,可以这样定义。

@property NSString *firstName;
@property NSString
*lastName;

然后在实现类代码里面,添加它的对应代码@synthesize的关键字

@synthesize firstName, lastName;

属性当然也可以指定为只读的,如下代码所示

@property (readonly) NSString *fullName;

另外,我们还需要清楚,属性默认是线程安全的,也就是atomic,还有它是强类型Strong的。

@interfaceXYZObject : NSObject
@property NSObject
*implicitAtomicObject; //atomic by default @property (atomic) NSObject *explicitAtomicObject; //explicitly marked atomic @end

在很多地方,我们使用属性的时候,都不需要指定它的线程安全特性,因为那样效率更高,一般的属性定义代码如下所示。

@property (strong, nonatomic) IBOutlet UILabel *lblName;
@property (strong, nonatomic) IBOutlet UITextField
*txtInput;

至于是不是所有的属性都应该指定为Strong,这个肯定不是的,strong的另外一种类型是weak,它是表示弱类型,强类型和弱类型主要是针对ARC来说的,它是引用计数的范畴,Strong相当于原来的retain。

一般情况下,为了避免一些强类型的对象属性导致出现相互引用的问题,在代理类和数据源对象,还有一些如UITable的对象属性,他们的属性定义必须指定为weak的。

2、对象的类型和初始化工作

在C#里面,我们知道,它里面包含了有一些基本类型(
Primitive type)
和一些包装后的对象类型,如它的基本类型包括string int char float long double decimal等等,它的对应包装类型有String Int32 Char Single Int64 Double Decimal等等。

在OC里面,同样也有这样的情况,OC的基本类型继承自C语言的基础类型,包括有int float double char 等基础类型,也有很多NS开头的引用类型(或者说包装类型),如NSString NSNumber NSDate NSData NSValue等等,而很多集合类型NSArray NSMutableArray NSDictionary等都需要添加引用类型的对象。

另外和C#的Object对象类似或者动态类型关键字dynamic指定的类型一样,OC里面包含了一个id的类型,这个是一个不确定的类型,它可以看成是一个任何类型的弱定义。

id
类型是一个独特的数据类型,在概念上,类似
java

Object
类,可以转换为任何数据类型。换句话说,
id
类型变量可以存放任何数据类型的对象。在内部处理上,这种类型被定义为指向对象的指针,实际上是一个指向这种对象的实例变量的指针。需要注意的是
id
是一个指针,所以在使用
id
的时候不需要加星号;比如说:id foo=nil;

1)类对象的初始化

我们知道,OC里面很多都是通过alloc init这样的方式进行初始化,如下面代码所示。

XYZObject *object = [[XYZObject alloc] init];

而C#里面大多数使用new方式进行初始化,其实OC里面,也一样可以通过new方式进行初始化,不过仅限在默认构造函数的方式进行,如下的代码是等同于上面的语句的。

XYZObject *object = [XYZObject new];

不过好像很多人都习惯用第一种方式初始化对象。

2)字符串的初始化

相信很多人使用OC的时候,第一个印象最深的我觉得可能是NSString类了,这个是和C#的String有点类似,都是固定的字符串对象,如果需要变化类型的字符串对象,C#里面是可以使用StringBuilder,而OC里面可以使用NSMutalbeString,NSMutableString好比一个字符串链表,它可以任意的动态在字符串中添加字符串 删除字符串 指定位置插入字符串,使用它来操作字符串会更加灵活。

字符串的定义和初始化和简单,我们可以通过下面的方式进行初始化。

NSString *someString = @"Hello, World!";

我们知道,C#也可以使用@字符进行赋值,虽然一般情况使用在多行的情况下,但是在OC,这个@字符不能省略。

其他数据类型初始化,很多都依靠@字符进行,这个@字符可以说是非常强大的,它也可以说是一个很好的语法糖,如下面初始化各种类型的代码如下(在OC里面,NSNumber可以放置任何引用类型)

    NSNumber *myBOOL =@YES;
NSNumber
*myFloat = @3.14f;
NSNumber
*myInt = @42;
NSNumber
*myLong = @42L;

NSNumber类型可以装纳各种类型,同样它也可以转换为其他对应的类型,如下代码所示

   int scalarMagic =[magicNumber intValue];
unsigned
int scalarUnsigned =[unsignedNumber unsignedIntValue];long scalarLong =[longNumber longValue];

BOOL scalarBool
=[boolNumber boolValue];float scalarSimpleFloat =[simpleFloat floatValue];double scalarBetterDouble =[betterDouble doubleValue];char scalarChar = [someChar charValue];

另外,由于OC里面引入了一个id类型,可以认为它的作用和C# 3.0引入的动态类型相当,它可以在运行时进行确定对象是否具有某个方法,而不会在编译的时候强制指定。

如下面的代码编译通过,运行的时候可能出错。

id someObject = @"Hello, World!";
[someObject removeAllObjects];

之所以编译的时候,不检查它的对象是否有removeAllObject接口方法,是因为这儿的someObjec指定为了id的动态类型,所以编译器会不检查它的方法。

3)对象集合的初始化

刚才上面介绍了字符串等各种类型的初始化,很多采用了强大的关键字@进行初始化,这个语法糖减少了很多繁琐的方法调用,对于集合的初始化,尤其这样。

如果按照传统的集合定义方式,一般是通过下面的方法。

NSArray *someArray =[NSArray arrayWithObjects:someObject, someString, someNumber, someValue, nil];

在里面的集合,最后必须加上一个nil的东西,这个在C#的领域里面是不需要增加这样的标识的,在Object C里面,如果你要通过arrayWithObjects方法进行构造,必须增加一个这样的东西,告诉它这个是最后了,如果你把这个放到第二位,那么构造的集合也只有两个对象了,很奇怪了。

如果采用了强大的@方法构造,一切都和C#相似了,这里你只能佩服它的神奇之处了。

NSArray *someArray = @[firstObject, secondObject, thirdObject];

如下面定义一个字符串的集合是这样的。

NSArray *unsortedStrings = @[@"gammaString", @"alphaString", @"betaString"];

在C#里面,我们经常用到了字典对象,这个对象非常方便。当然在OC里面,也肯定会有这样的东西,毕竟很多语言都会支持的。

这个字典类型也是一个集合类型,它的传统构造方法如下所示

NSDictionary *dictionary =[NSDictionary dictionaryWithObjectsAndKeys:
someObject,
@"anObject",@"Hello, World!", @"helloString",
@
42, @"magicNumber",
someValue,
@"aValue",
nil];

它这个看起来很怪异,添加指点是按照object,key的这样方式添加的,这个与我们使用C#的习惯有很大的不同哦,而且最后还带了一个nil的尾巴。

如果采用@构造函数,一切又都清净了,已经是key,value方式进行存储,而且不用nil了,如果你添加了nil,那么会出错的。

NSDictionary *dictionary =@{@"anObject": someObject,@"helloString" : @"Hello, World!",@"magicNumber" : @42,@"aValue": someValue
};

集合中,如果取某个对象,那么通过下面的方法进行获取

 NSNumber *storedNumber = [dictionary objectForKey:@"magicNumber"];

也可以通过下标括符进行获取

NSNumber *storedNumber = dictionary[@"magicNumber"];

如果是一般的数组集合,可以通过下面方式获取,这种方式和c#很类似了。

NSNumber *storedNumber = array[0];

由于时间和篇幅的问题,关于OC的各种和C#对比的特性,以后继续介绍,OC里面还涉及很多相关的特点,如扩展方法,协议(类似接口),代码块等等内容,以及XCode的各种使用特性,有空继续介绍。

本随笔系列主要介绍从一个Windows平台从事C#开发到Mac平台苹果开发的一系列感想和体验历程,本系列文章是在起步阶段逐步积累的,希望带给大家更好,更真实的转换历程体验。本文继续上一篇随笔《
从C#到Object C,循序渐进学习苹果开发(2)--Objective-C和C#的差异
》,继续对比介绍它们两者之间的差异,以便我们从C#阵营过来的人员加深印象,深入了解Objective-C语言的特性。本篇随笔主要针对Objective-C里面的分类(category)和协议Protocal概念的理解进行介绍。

1、分类(category)概念和使用

如果我们使用过C#,我们都知道,C#里面有一个叫做扩展函数的东西,可以在不继承已有类的情况下,给存在的类增加一些原本没有的接口函数,Objective-C的分类概念和这个很相似,甚至可以说是同一类型的东西,虽然不知道他们谁先谁后出现,这个东西的引入,能使得编程方面更加丰富高效。

Objective-C提供了一种与众不同的方式——Category,可以动态的为已经存在的类添加新的行为。这样可以保证类的原始设计规模较小,功能增加时再逐步扩展。使用Category对类进行扩展时,不需要访问其源代码,也不需要创建子类。Category使用简单的方式,实现了类的相关方法的模块化,把不同的类方法分配到不同的分类文件中。不过Category并不能给类扩展出属性,这点要注意,因为Object C不支持这样的属性扩展。

分类(Category)的定义语法如下所示。

@interfaceClassName (CategoryName)@end

这里好像它们还有一个约定俗成的习惯,将声明文件和实现文件名称统一采用“原类名+Category”的方式命名。所以OC的这种功能虽然和C#功能差不多,但是这点约定和C#不一样,C#不管你放到哪里都行,但是我们还是会应该尊重它的规则。

例如,我们给XYZPerson类增加一个扩展方法的定义如下所示,这个定义的函数约定是放到文件"XYZPerson+XYZPersonNameDisplayAdditions.h"里面。

#import "XYZPerson.h"
 
@interfaceXYZPerson (XYZPersonNameDisplayAdditions)- (NSString *)testMethod;@end

那么它的实现代码如下所示,它的代码约定是放到 "XYZPerson+XYZPersonNameDisplayAdditions.m"里面。

#import "XYZPerson+XYZPersonNameDisplayAdditions.h"
 
@implementationXYZPerson (XYZPersonNameDisplayAdditions)- (NSString *)testMethod {return [NSString stringWithFormat:@"%@, %@", self.lastName, self.firstName];
}
@end

在C#里面,扩展方法是命名空间相关的,一旦跳出了命名空间的范围,这个扩展函数就不在起作用,而Objective-C的这个和类一样,没有命名空间的概念,因此在扩展的时候,需要小心谨慎一点,否则容易导致分类的接口和类本身发生冲突。基于这个原因,所以苹果建议也是给分类的接口增加一个前缀,命名则采用接口的一贯规则,如下面代码所示。

@interfaceNSSortDescriptor (XYZAdditions)+ (id)xyz_sortDescriptorWithKey:(NSString *)key ascending:(BOOL)ascending;@end

这样扩展方法名称虽然长了一点,但是基本上确保和普通的接口方法不会发生冲突了。

Category的使用场景:

1、当你在定义类的时候,在某些情况下(例如需求变更),你可能想要为其中的某个或几个类中添加方法。
2、一个类中包含了许多不同的方法需要实现,而这些方法需要不同团队的成员实现
3、当你在使用基础类库中的类时,你可能希望这些类实现一些你需要的方法。
遇到以上这些需求,Category可以帮助你解决问题。当然,使用Category也有些问题需要注意,
1、Category可以访问原始类的实例变量,但不能添加变量,如果想添加变量,可以考虑通过继承创建子类。
2、Category可以重载原始类的方法,但不推荐这么做,这么做的后果是你再也不能访问原来的方法。如果确实要重载,正确的选择是创建子类。
3、和普通接口有所区别的是,在分类的实现文件中可以不必实现所有声明的方法,只要你不去调用它。

还有一种成为类扩展的功能,它是针对存在代码的类的情况,也就是你的类代码和你扩展的源码是同时编译的情况下。

类扩展的方法和上面的分类类似,他们不需要写扩展分类的名称,这个有点像匿名扩展分类的概念了,如下所示

@interfaceClassName ()@end

这个匿名的扩展分类,和普通的Category不同,它除了可以方法外,还可以添加属性或者变量的。

2、协议Protocal

这个概念有很大程度上和C#的接口类似,但是它有所不同,它可以可选的实现接口
@optional
,也有必选的实现接口
@required
,虽然Objective-C里面已经有一个关键字 @interface,不过这个和Protocal还是有不同的。

和C#的接口一样,这种协议也可以继承自另外一个Protocal,也就是他们可以有继承关系。

@protocol NewProtocal   <Protocal>
@end

由于Objective-C开发的很多应用,如IOS的应用,他们在MVC的开发模型里面,都大量使用了代理模式,这种Protocal很好的处理了这种关系。
在iOS和OS X开发中,Apple采用了大量的代理模式来实现MVC中View和Controller的解耦。

例如UIView产生的所有事件,都是通过委托的方式交给Controller完成。根据约定,框架中后缀为Delegate的都是Protocol,例如UIApplicationDelegate,UIWebViewDelegate等。

在C#里面有很多如IClonable,
IEnumerable这样的接口,只要实现了,就能实现克隆和枚举,在Objective-C里面,这个就是可以使用Protocal来替代了,如果某个协议继承了NSObject,那么这

是代表在此声明的协议,是NSObject协议的衍生协议(不是NSObject类),也就是说,这里的语境理解NSObject是一个协议,如果是在@Interface里面的继承关系,那么那个就是NSObject对象。有点意思哦。

下面是一个可选和必选的协议定义例子。

@protocolXYZPieChartViewDataSource-(NSUInteger)numberOfSegments;-(CGFloat)sizeOfSegmentAtIndex:(NSUInteger)segmentIndex;
@optional
- (NSString *)titleForSegmentAtIndex:(NSUInteger)segmentIndex;-(BOOL)shouldExplodeSegmentAtIndex:(NSUInteger)segmentIndex;
@required
- (UIColor *)colorForSegmentAtIndex:(NSUInteger)segmentIndex;@end

由于协议有可选和必选,如果我们想知道某个动态的对象是否具有某个接口函数,就是通过@selector操作符来进行判断的。

NSString *thisSegmentTitle;if([self.dataSource respondsToSelector:@selector(titleForSegmentAtIndex:)]) {
thisSegmentTitle
=[self.dataSource titleForSegmentAtIndex:index];
}

和C#的接口定义类似,Objective-C的一个类对象它可以实现多的协议,如下例子是一个类的接口定义实现几个协议的情况。

@interface MyClass : NSObject <MyProtocol, AnotherProtocol, YetAnotherProtocol>...@end

这样就实现了MyClass对象只有一个基类对象,但是可以实现多个协议(C#是多个接口)的情况。