博客园-专家区http://www.cnblogs.com/expert/程序员的网上家园zh-cnFri, 10 Feb 2012 09:35:26 GMTFri, 10 Feb 2012 09:35:26 GMT60TX Text Control文字处理教程（11）使用文本框http://www.cnblogs.com/powertoolsteam/archive/2012/02/10/2345523.html葡萄城控件技术团队博客葡萄城控件技术团队博客Fri, 10 Feb 2012 07:36:00 GMThttp://www.cnblogs.com/powertoolsteam/archive/2012/02/10/2345523.html

本章主要讲述如何利用文本框控件来控制和操作文本。相应的源代码可以在TX Text Control.NET的安装目录中找到：
        Samples\WinForms\VB.NET\ Text Frames
        Samples\WinForms\CSharp\ Text Frames
第一步：插入文本框
插入文本框操作首先需要创建一个 TextFrame 的实例， 然后将其添加到 TextFrameCollection集合对象中。

[C#] 
TXTextControl.TextFrame newFrame = new TXTextControl.TextFrame(new Size(1000,1000)); 
textControl1.TextFrames.Add (newFrame, TXTextControl.HorizontalAlignment.Left, 
    -1,TXTextControl.TextFrameInsertionMode.DisplaceText);



插入文本框之后，可以通过单击它的边框来选择该文本框，然后通过鼠标拖动它的边框来移动或者改变其大小。Text Control 还提供了一个内置的集成对话框，可以通过它来设置文本框的外观属性，在代码中可以通过TextFrameAttributesDialog来显示该对话框：

[C#] 
textControl1.TextFrameAttributesDialog();


在示例程序中，调用该对话框的代码是单击菜单项来调用的，而对于的菜单项是否可用需要以下代码来控制：

[C#] 
mnuTextFrame_Properties.Enabled = (textControl1.TextFrames.GetItem() != null);



第二步：标签打印机
        下面演示如何快速插入多个文本框，程序中结合标签打印来说明这样操作，标签打印常用于地址或者徽章标签打印，程序的源代码可以在TextFrames\Printing Address Lables目录下找到。
        示例程序中包含一个对话框，用户可以在对话框中输入标签的相关信息，比如：数量、大小等。

依照以上对话框中的设置可以创建相应的文本框。

        以上创建的文本框可以通过手动输入、从文件或者数据库中取值的方式来添加相应的文本信息。示例程序中当点击Fill菜单时，程序会根据文本框的域标识来填充相应“Address no.”文本。为了演示从文件中加载文本信息，需要用Selection.Load来代替Selection.Text属性：

[C#] 
private void mnuLabel_FillIn_Click(object sender, System.EventArgs e) 
{ 
    int n = 0; 
    foreach (TXTextControl.TextFrame frame in textControl1.TextFrames) 
    { 
        frame.Selection.Text = "Text Frame #" + Convert.ToString(n++); 
    } 
}



TX Text Control试用版下载

作者: 葡萄城控件技术团队博客 发表于 2012-02-10 15:36 原文链接

评论: 0　查看评论　发表评论

最新新闻：
· 苹果征集iPad 3发布会演示应用 重点是图形应用(2012-02-10 17:23)
· 京东商城涉足汽车销售 将上线售车频道(2012-02-10 17:21)
· 亚马逊新广告挑衅苹果：一个iPad可买三台kindle(2012-02-10 17:20)
· 动视暴雪确认今年第二季度推出《暗黑破坏神3》(2012-02-10 16:59)
· 官方承认 Google Bar 逆行倒施(2012-02-10 16:55)

编辑推荐：高级编程语言的发展历程

网站导航：博客园首页  我的园子  新闻  闪存  博问  知识库

]]>android UI进阶之实现listview的分页加载http://www.cnblogs.com/noTice520/archive/2012/02/10/2345057.htmlnoTice501noTice501Fri, 10 Feb 2012 03:26:00 GMThttp://www.cnblogs.com/noTice520/archive/2012/02/10/2345057.html

作者: noTice501 发表于 2012-02-10 11:26 原文链接

评论: 0　查看评论　发表评论

最新新闻：
· 苹果征集iPad 3发布会演示应用 重点是图形应用(2012-02-10 17:23)
· 京东商城涉足汽车销售 将上线售车频道(2012-02-10 17:21)
· 亚马逊新广告挑衅苹果：一个iPad可买三台kindle(2012-02-10 17:20)
· 动视暴雪确认今年第二季度推出《暗黑破坏神3》(2012-02-10 16:59)
· 官方承认 Google Bar 逆行倒施(2012-02-10 16:55)

网站导航：博客园首页  我的园子  新闻  闪存  博问  知识库

]]>[WCF REST] 通过ASP.NET Output Caching实现声明式缓存http://www.cnblogs.com/artech/archive/2012/02/10/wcf-rest-output-caching.htmlArtechArtechFri, 10 Feb 2012 00:58:00 GMThttp://www.cnblogs.com/artech/archive/2012/02/10/wcf-rest-output-caching.html

ASP.NET的输出缓存（Output Caching）机制允许我们针对整个Web页面或者页面的某个部分（主要针对用户控件）最终呈现的HTML进行缓存。对于后续针对相同资源的请求，只需要直接将缓存的HTML予以回复而无须按照页面处理生命周期对每次请求进行重复处理。WCF通过操作行为AspNetCacheProfileAttribute利用ASP.NET的输出缓存提供一种针对于某个操作的声明式缓存机制。[源代码从这里下载]

一、AspNetCacheProfileAttribute

WCF对ASP.NET缓存的支持是通过AspNetCacheProfileAttribute特性来实现的。通过如下的代码我们不难看出AspNetCacheProfileAttribute是实现了IOperationBehavior接口的操作行为，我们可以直接将其应用到契约接口/类中的某个具有缓存需要的操作方法上。

   1: [AttributeUsage(AttributeTargets.Method)]
   2: public sealed class AspNetCacheProfileAttribute : Attribute, IOperationBehavior
   3: {
   4:     //其他成员
   5:     public AspNetCacheProfileAttribute(string cacheProfileName);
   6:     public string CacheProfileName { get; }
   7: }

AspNetCacheProfileAttribute构造函数参数cacheProfileName表示的CacheProfile的配置名称，目标操作按照定义在相应CacheProfile的缓存策略实施缓存。CacheProfile配置在<system.web>/<caching>/<outputCacheSettings>/<outputCacheProfiles>节点下。

   1: <configuration>
   2:   <connectionStrings>
   3:     <add name="localDb" 
   4:          connectionString="Server=.; Database=TestDb; Uid=sa; Pwd=password"
   5:          providerName="System.Data.SqlClient"/>
   6:   </connectionStrings>
   7:   <system.web>
   8:     <caching>
   9:       <outputCacheSettings>
  10:         <outputCacheProfiles>
  11:           <add name="default" 
  12:                duration="60" 
  13:                varyByParam="none" 
  14:                sqlDependency="TestDb: TestTable"/>
  15:         </outputCacheProfiles>
  16:       </outputCacheSettings>
  17:       <sqlCacheDependency>
  18:         <databases>
  19:           <add name="TestDb" connectionStringName="localDb"/>
  20:         </databases>
  21:       </sqlCacheDependency>
  22:     </caching>
  23:   </system.web>
  24: </configuration>

在如上所示的配置片断中，我们定义了一个名称为default的CacheProfile。代表缓存时间的duration属性被设置为60，意味着缓存项在被存储之后1分钟之后实失效；属性varyByParam被设置为none表示缓存项与请求的查询字符串无关。此外，该CacheProfile还设置针对某个本地数据库中的TestTable表的SQL依赖（SQL Dependency）。关于CacheProfile的配置属于ASP.NET的范畴，在这里我们不会作过多的讨论。

既然是采用ASP.NET输出缓存，WCF服务自然需要采用IIS寄宿并采用ASP.NET 兼容模式。值得一提的是，基于AspNetCacheProfileAttribute的输出缓存仅仅针对HTTP-GET。

二、实例演示：创建采用输出缓存的服务

接下来我们通过一个简单的实例来演示如何通过操作行为对某个操作的返回值实施缓存，为此我们创建一个用于返回当前时间的服务。如下所示的是作为服务契约的ITime接口的定义，AspNetCacheProfileAttribute特性被应用到了用于返回当前时间的操作方法GetCurrentTime上。

   1: using System;
   2: using System.ServiceModel;
   3: using System.ServiceModel.Web;
   4: namespace Artech.WcfServices.Service.Interface
   5: {
   6:     [ServiceContract(Namespace = "http://www.artech.com/")]
   7:     public interface ITime
   8:     {
   9:         [WebGet(UriTemplate = "/current")]
  10:         [AspNetCacheProfile("default")]
  11:         DateTime GetCurrentTime();
  12:     }
  13: }

实现了契约接口ITime的服务类型TimeService定义如下。我们将AspNetCompatibilityRequirementsAttribute特性应用在服务类型上并将RequirementsMode属性设置为Allowed以提供对ASP.NET兼容模式的支持。

   1: using System;
   2: using System.ServiceModel.Activation;
   3: using Artech.WcfServices.Service.Interface;
   4: namespace Artech.WcfServices.Service
   5: {
   6:     [AspNetCompatibilityRequirements(
   7:      RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]
   8:     public class TimeService : ITime
   9:     {
  10:         public DateTime GetCurrentTime()
  11:         {
  12:             return DateTime.Now;
  13:         }
  14:     }
  15: }

在一个Web项目中我们为通过IIS寄宿的服务TimeService添加一个对应的.svc文件（TimeService.svc），如下所示的是<%@ServiceHost%>指令的定义。表示ServiceHostFactory类型的指令属性Factory被设置为System.ServiceModel.Activation.WebServiceHostFactory.

   1: <%@ ServiceHost Service="Artech.WcfServices.Service.TimeService" Factory="System.ServiceModel.Activation.WebServiceHostFactory"%>

我们在作为服务宿主的Web项目下添加一个配置文件（Web.config）并定义如下的配置。除了服务寄宿的基本配置外，我们将<system.serviceModel>/<serviceHostingEnvironment >配置节的aspNetCompatibilityEnabled属性设置为True以开启ASP.NET兼容模式。应用在操作方法GetCurrentTime上的AspNetCacheProfileAttribute特性中指定的名称为default的CacheProfile定义在该配置中，duration和varyByParam分别被设置为60和none。

   1: <configuration>
   2:     <system.serviceModel>
   3:         <services>
   4:             <service name="Artech.WcfServices.Service.TimeService">
   5:                 <endpoint binding="webHttpBinding"
   6:                           contract="Artech.WcfServices.Service.Interface.ITime"/>
   7:             </service>
   8:         </services>
   9:       <serviceHostingEnvironment aspNetCompatibilityEnabled="true" />
  10:     </system.serviceModel>  
  11:   <system.web>
  12:     <caching>
  13:       <outputCacheSettings>
  14:         <outputCacheProfiles>
  15:           <add name="default" duration="60" varyByParam="none"/>
  16:         </outputCacheProfiles>
  17:       </outputCacheSettings>      
  18:     </caching>
  19:   </system.web>
  20: </configuration>

作为客户端的控制台程序在进行了相应配置之后通过如下的代码进行服务的调用。在这段代码中，我们通过创建的服务代理进行了5次服务调用，并将获取的时间打印出来。每次服务的时间间隔为1秒。

   1: using (ChannelFactory<ITime> channelFactory =  new ChannelFactory<ITime>("timeService"))
   2: {
   3:     ITime proxy = channelFactory.CreateChannel();
   4:     for (int i = 0; i < 5; i++)
   5:     { 
   6:         Console.WriteLine(proxy.GetCurrentTime().ToLongTimeString());
   7:         Thread.Sleep(1000);
   8:     }
   9: }

客户端代码执行之后会在控制台上输出如下的结果。由于服务端通过ASP.NET的输出缓存对第一次执行GetCurrentTime操作的结果进行了缓存，所以客户端返回的时间都是相同的。

   1: 4:48:43 PM
   2: 4:48:43 PM
   3: 4:48:43 PM
   4: 4:48:43 PM
   5: 4:48:43 PM

三、 AspNetCacheProfileAttribute是如何实现输出缓存的？

既然我们采用ASP.NET兼容模式来寄宿服务，意味着我们调用某个服务与访问某个页面没有本质的区别，所以基于Web页面的输出缓存能够应用于基于某个服务操作的调用就不足为奇了。现在有这么一个问题：通过AspNetCacheProfileAttribute特性指定CacheProfile是如何生效的？

如果对ASP.NET具有一定的了解，应该知道可以通过当前HttpResponse（HttpContext.Current.Response）的Cache属性表示的HttpCachePolicy对象来控制当前输出缓存的基本策略。实际上AspNetCacheProfileAttribute就是通过这种方式将定义在指定CacheProfile的缓存策略应用到针对当前操作的调用上的。

具体来说，AspNetCacheProfileAttribute针对输出缓存策略的控制是通过一个实现了接口IParameterInspector的自定义参数检验器实现的，这是一个名称为CachingParameterInspector的内部类型。操作行为AspNetCacheProfileAttribute通过实现的ApplyDispatchBehavior方法将针对某个CacheProfile创建的CachingParameterInspector对象添加到当前分发操作（DispatchOperation）的参数检验器列表中。

   1: internal class CachingParameterInspector : IParameterInspector
   2: {
   3:     public CachingParameterInspector(string cacheProfileName);
   4:     public object BeforeCall(string operationName, object[] inputshens);
   5:     public void AfterCall(string operationName, object[] outputs, object returnValue, object correlationState)
   6:     {
   7:         //将指定CacheProfile的输出缓存策略应用到当前HttpResponse
   8:     }
   9: }

如上面的代码片断所示，当AfterCall方法被执行的之后，在构造函数中指定的CacheProfile定义的输出缓存策略应用到当前HttpResponse。而AfterCall会在操作执行之后，回复消息序列化之前被执行。

作者: Artech 发表于 2012-02-10 08:58 原文链接

评论: 10　查看评论　发表评论

最新新闻：
· 苹果征集iPad 3发布会演示应用 重点是图形应用(2012-02-10 17:23)
· 京东商城涉足汽车销售 将上线售车频道(2012-02-10 17:21)
· 亚马逊新广告挑衅苹果：一个iPad可买三台kindle(2012-02-10 17:20)
· 动视暴雪确认今年第二季度推出《暗黑破坏神3》(2012-02-10 16:59)
· 官方承认 Google Bar 逆行倒施(2012-02-10 16:55)

编辑推荐：高级编程语言的发展历程

网站导航：博客园首页  我的园子  新闻  闪存  博问  知识库

]]>深入理解JavaScript系列（20）：《你真懂JavaScript吗？》答案详解http://www.cnblogs.com/TomXu/archive/2012/02/10/2342098.html汤姆大叔汤姆大叔Fri, 10 Feb 2012 00:54:00 GMThttp://www.cnblogs.com/TomXu/archive/2012/02/10/2342098.html

介绍

昨天发的《大叔手记（19）：你真懂JavaScript吗？》里面的5个题目，有很多回答，发现强人还是很多的，很多人都全部答对了。

今天我们来对这5个题目详细分析一下，希望对大家有所帮助。

注：

问题来自大名鼎鼎的前端架构师Baranovskiy的帖子《So, you think you know JavaScript?》。
答案也是来自大名鼎鼎的JS牛人Nicholas C. Zakas的帖子《Answering Baranovskiy’s JavaScript quiz》——《JavaScript高级程序设计》一书的原作者
(但题目2的解释貌似有点问题）

OK，我们先看第一题

题目1

if (!("a" in window)) {
    var a = 1;
}
alert(a);

代码看起来是想说：如果window不包含属性a，就声明一个变量a，然后赋值为1。

你可能认为alert出来的结果是1，然后实际结果是“undefined”。要了解为什么，我们需要知道JavaScript里的3个概念。

首先，所有的全局变量都是window的属性，语句 var a = 1;等价于window.a = 1; 你可以用如下方式来检测全局变量是否声明：

"变量名称" in window

第二，所有的变量声明都在范围作用域的顶部，看一下相似的例子：

alert("a" in window);
var a;

此时，尽管声明是在alert之后，alert弹出的依然是true，这是因为JavaScript引擎首先会扫墓所有的变量声明，然后将这些变量声明移动到顶部，最终的代码效果是这样的：

var a;
alert("a" in window);

这样看起来就很容易解释为什么alert结果是true了。

第三，你需要理解该题目的意思是，变量声明被提前了，但变量赋值没有，因为这行代码包括了变量声明和变量赋值。

你可以将语句拆分为如下代码：

var a;    //声明
a = 1;    //初始化赋值

当变量声明和赋值在一起用的时候，JavaScript引擎会自动将它分为两部以便将变量声明提前，不将赋值的步骤提前是因为他有可能影响代码执行出不可预期的结果。

所以，知道了这些概念以后，重新回头看一下题目的代码，其实就等价于：

var a;
if (!("a" in window)) {
    a = 1;
}
alert(a);

这样，题目的意思就非常清楚了：首先声明a，然后判断a是否在存在，如果不存在就赋值为1，很明显a永远在window里存在，这个赋值语句永远不会执行，所以结果是undefined。

大叔注：提前这个词语显得有点迷惑了，其实就是执行上下文的关系，因为执行上下文分2个阶段：进入执行上下文和执行代码，在进入执行上下文的时候，创建变量对象VO里已经有了：函数的所有形参、所有的函数声明、所有的变量声明

VO(global) = {
    a: undefined
}

这个时候a已经有了；

然后执行代码的时候才开始走if语句，详细信息请查看《深入理解JavaScript系列（12）：变量对象（Variable Object）》中的处理上下文代码的2个阶段小节。

大叔注：相信很多人都是认为a在里面不可访问，结果才是undefined的吧，其实是已经有了，只不过初始值是undefined，而不是不可访问。

题目2

var a = 1,
    b = function a(x) {
        x && a(--x);
    };
alert(a);

这个题目看起来比实际复杂，alert的结果是1；这里依然有3个重要的概念需要我们知道。

首先，在题目1里我们知道了变量声明在进入执行上下文就完成了；第二个概念就是函数声明也是提前的，所有的函数声明都在执行代码之前都已经完成了声明，和变

量声明一样。澄清一下，函数声明是如下这样的代码：

function functionName(arg1, arg2){
    //函数体
}

如下不是函数，而是函数表达式，相当于变量赋值：

var functionName = function(arg1, arg2){
    //函数体
};

澄清一下，函数表达式没有提前，就相当于平时的变量赋值。

第三需要知道的是，函数声明会覆盖变量声明，但不会覆盖变量赋值，为了解释这个，我们来看一个例子：

function value(){
    return 1;
}
var value;
alert(typeof value);    //"function"

尽快变量声明在下面定义，但是变量value依然是function，也就是说这种情况下，函数声明的优先级高于变量声明的优先级，但如果该变量value赋值了，那结果就完全不一样了：

function value(){
    return 1;
}
var value = 1;
alert(typeof value);    //"number"

该value赋值以后，变量赋值初始化就覆盖了函数声明。

重新回到题目，这个函数其实是一个有名函数表达式，函数表达式不像函数声明一样可以覆盖变量声明，但你可以注意到，变量b是包含了该函数表达式，而该函数表达式的名字是a；不同的浏览器对a这个名词处理有点不一样，在IE里，会将a认为函数声明，所以它被变量初始化覆盖了，就是说如果调用a(--x)的话就会出错，而其它浏览器在允许在函数内部调用a(--x)，因为这时候a在函数外面依然是数字。基本上，IE里调用b(2)的时候会出错，但其它浏览器则返回undefined。

理解上述内容之后，该题目换成一个更准确和更容易理解的代码应该像这样：

var a = 1,
    b = function(x) {
        x && b(--x);
    };
alert(a);

这样的话，就很清晰地知道为什么alert的总是1了，详细内容请参考《深入理解JavaScript系列（2）：揭秘命名函数表达式》中的内容。

大叔注：安装ECMAScript规范，作者对函数声明覆盖变量声明的解释其实不准确的，正确的理解应该是如下：

进入执行上下文： 这里出现了名字一样的情况，一个是函数申明，一个是变量申明。那么，根据深入理解JavaScript系列（12）：变量对象（Variable Object）介绍的，填充VO的顺序是: 函数的形参 -> 函数申明 -> 变量申明。
上述例子中，变量a在函数a后面，那么，变量a遇到函数a怎么办呢？还是根据变量对象中介绍的，当变量申明遇到VO中已经有同名的时候，不会影响已经存在的属性。而函数表达式不会影响VO的内容，所以b只有在执行的时候才会触发里面的内容。

题目3

function a(x) {
    return x * 2;
}
var a;
alert(a);

这个题目就是题目2里的大叔加的注释了，也就是函数声明和变量声明的关系和影响，遇到同名的函数声明，VO不会重新定义，所以这时候全局的VO应该是如下这样的：

VO(global) = {
    a: 引用了函数声明“a”
}

而执行a的时候，相应地就弹出了函数a的内容了。

题目4

function b(x, y, a) {
    arguments[2] = 10;
    alert(a);
}
b(1, 2, 3);

关于这个题目，NC搬出了262-3的规范出来解释，其实从《深入理解JavaScript系列（12）：变量对象（Variable Object）》中的函数上下文中的变量对象一节就可以清楚地知道，活动对象是在进入函数上下文时刻被创建的，它通过函数的arguments属性初始化。arguments属性的值是Arguments对象：

AO = {
  arguments: <ArgO>
};

Arguments对象是活动对象的一个属性，它包括如下属性：

  1. callee — 指向当前函数的引用
  2. length — 真正传递的参数个数
  3. properties-indexes (字符串类型的整数) 属性的值就是函数的参数值(按参数列表从左到右排列)。 properties-indexes内部元素的个数等于arguments.length. properties-indexes 的值和实际传递进来的参数之间是共享的。

这个共享其实不是真正的共享一个内存地址，而是2个不同的内存地址，使用JavaScript引擎来保证2个值是随时一样的，当然这也有一个前提，那就是这个索引值要小于你传入的参数个数，也就是说如果你只传入2个参数，而还继续使用arguments[2]赋值的话，就会不一致，例如：

function b(x, y, a) {
    arguments[2] = 10;
    alert(a);
}
b(1, 2);

这时候因为没传递第三个参数a，所以赋值10以后，alert(a)的结果依然是undefined，而不是10，但如下代码弹出的结果依然是10，因为和a没有关系。

function b(x, y, a) {
    arguments[2] = 10;
    alert(arguments[2]);
}
b(1, 2);

题目5

function a() {
    alert(this);
}
a.call(null);

这个题目可以说是最简单的，也是最诡异的，因为如果没学到它的定义的话，打死也不会知道结果的，关于这个题目，我们先来了解2个概念。

首先，就是this值是如何定义的，当一个方法在对象上调用的时候，this就指向到了该对象上，例如：

var object = {
    method: function() {
        alert(this === object);    //true
    }
}
object.method();

上面的代码，调用method()的时候this被指向到调用它的object对象上，但在全局作用域里，this是等价于window（浏览器中，非浏览器里等价于global），在如果一个function的定义不是属于一个对象属性的时候（也就是单独定义的函数），函数内部的this也是等价于window的，例如：

function method() {
    alert(this === window);    //true
}
method();

了解了上述概念之后，我们再来了解一下call()是做什么的，call方法作为一个function执行代表该方法可以让另外一个对象作为调用者来调用，call方法的第一个参数是对象调用者，随后的其它参数是要传给调用method的参数（如果声明了的话），例如：

function method() {
    alert(this === window);
}
method();    //true
method.call(document);   //false

第一个依然是true没什么好说的，第二个传入的调用对象是document，自然不会等于window，所以弹出了false。

另外，根据ECMAScript262规范规定：如果第一个参数传入的对象调用者是null或者undefined的话，call方法将把全局对象（也就是window）作为this的值。所以，不管你什么时候传入null，其this都是全局对象window，所以该题目可以理解成如下代码：

function a() {
    alert(this);
}
a.call(window);

所以弹出的结果是[object Window]就很容易理解了。

总结

这5个题目虽然貌似有点偏，但实际上考察的依然是基本概念，只有熟知了这些基本概念才能写出高质量代码。

关于JavaScript的基本核心内容和理解基本上在该系列就到此为止了，接下来的章节除了把五大原则剩余的2篇补全依然，会再加两篇关于DOM的文章，然后就开始转向整理关于JavaScript模式与设计模式相关的文章了（大概10篇左右），随后再会花几个章节来一个实战系列。

更多题目

如果大家有兴趣，可以继续研究下面的一些题目，详细通过这些题目也可以再次加深对JavaScript基础核心特性的理解。

大叔注：这些题目也是来自出这5个题目的人，当然如果你能答对4个及以上并且想拿高工资的话，请联系我。

  1. 找出数字数组中最大的元素（使用Match.max函数）
  2. 转化一个数字数组为function数组（每个function都弹出相应的数字）
  3. 给object数组进行排序（排序条件是每个元素对象的属性个数）
  4. 利用JavaScript打印出Fibonacci数（不使用全局变量）
  5. 实现如下语法的功能：var a = (5).plus(3).minus(6); //2
  6. 实现如下语法的功能：var a = add(2)(3)(4); //9

同步与推荐

本文已同步至目录索引：深入理解JavaScript系列

深入理解JavaScript系列文章，包括了原创，翻译，转载等各类型的文章，如果对你有用，请推荐支持一把，给大叔写作的动力。

作者: 汤姆大叔 发表于 2012-02-10 08:54 原文链接

评论: 42　查看评论　发表评论

最新新闻：
· 苹果征集iPad 3发布会演示应用 重点是图形应用(2012-02-10 17:23)
· 京东商城涉足汽车销售 将上线售车频道(2012-02-10 17:21)
· 亚马逊新广告挑衅苹果：一个iPad可买三台kindle(2012-02-10 17:20)
· 动视暴雪确认今年第二季度推出《暗黑破坏神3》(2012-02-10 16:59)
· 官方承认 Google Bar 逆行倒施(2012-02-10 16:55)

编辑推荐：高级编程语言的发展历程

网站导航：博客园首页  我的园子  新闻  闪存  博问  知识库

]]>淘宝API开发系列---淘宝API的测试及使用2http://www.cnblogs.com/wuhuacong/archive/2012/02/10/2344722.html伍华聪伍华聪Thu, 09 Feb 2012 23:36:00 GMThttp://www.cnblogs.com/wuhuacong/archive/2012/02/10/2344722.html

继续前面一篇随笔《淘宝API开发系列---淘宝API的测试及使用》，来继续介绍淘宝API的具体代码开发部分，上篇主要是介绍淘宝SDK开发的一些流程及必备的信息，以及掌握如何学会利用API文档、淘宝API测试工具来获取我们所需的数据，其中我一般倾向于获取Json数据，然后进行分析，其中Json数据可以通过JsonView工具（http://jsonviewer.codeplex.com/）进行格式化显示，方便我们了解和区分各个属性的信息。另外淘宝的SDK里面，封装了很多对象，我们通过数据就可以获取到相关的信息了，不过注意的就是，我们每个接口调用，都要传入Fields的属性，如果我们没有指定相应的属性字段，那么接口返回的数据，就没有这项的，淘宝SDK的对象属性就会为空。

 

 通过以上的工具，我们就能可视化属性的信息了，对接口数据的理解就更加清晰，首先我们来看看我测试例子的运行效果如下所示。

 

 其中上面例子的代码如下所示。

        private void TestUserGet()
        {
            //单独用户的信息
            Console.WriteLine("单独用户的信息");
            UserGetRequest req = new UserGetRequest(); //实例化具体API对应的Request类
            req.Fields = "user_id,nick,created,buyer_credit,type,sex";
            req.Nick = "wuhuacong";
            UserGetResponse rsp = myclient.Execute(req);//执行API请求并将该类转换为response对象
            Console.WriteLine(rsp.Body);
            if (rsp.User != null)
            {
                //Console.WriteLine(rsp.User.Nick);
                //Console.WriteLine(ObjectToString(rsp.User));
                List<User> list = new List<User>();
                list.Add(rsp.User);
                this.winGridView1.DisplayColumns = req.Fields.Replace("_", "");//对应字段的属性没有“_”字符的
                this.winGridView1.DataSource = list;
            }
        }

        private void TestItemGet()
        {
            //单独商品的信息
            Console.WriteLine("单独商品的信息");
            ItemGetRequest req = new ItemGetRequest();
            req.Fields = "num_iid,title,nick,pic_path,cid,price,type,location.city,delist_time,post_fee";
            req.NumIid = 3838293428L;
            ItemGetResponse itemRsp = myclient.Execute(req);
            if (itemRsp != null && itemRsp.Item != null)
            {
                //Console.WriteLine(itemRsp.Item.Nick);
                //Console.WriteLine(ObjectToString(itemRsp.Item));
                List<Item> list = new List<Item>();
                list.Add(itemRsp.Item);
                this.winGridView1.DisplayColumns = req.Fields.Replace("_", "");//对应字段的属性没有“_”字符的
                this.winGridView1.DataSource = list;
            }
        }

        private void TestItemSearch()
        {
            //查询商品信息（不含类别）
            Console.WriteLine("查询商品信息（不含类别）");
            ItemsGetRequest req = new ItemsGetRequest();
            req.Fields = "num_iid,title,nick,pic_url,cid,price,type,delist_time,post_fee,score,volume";//,location.city,location.state";
            req.Q = "笔记本";
            //itemReq.Cid = "14";
            req.OrderBy = "volume:desc";
            req.PageNo = 1;
            req.PageSize = 40;

            //显示列表信息
            ItemsGetResponse itemRsp = myclient.Execute(req);
            if (itemRsp != null)
            {
                //Console.WriteLine(itemRsp.TotalResults);
                //foreach (Item item in itemRsp.Items)
                //{
                //    Console.WriteLine(ObjectToString(item));
                //}
                this.winGridView1.DisplayColumns = req.Fields.Replace("_", "");//对应字段的属性没有“_”字符的
                this.winGridView1.DataSource = itemRsp.Items;
            }

        } 

对于需要获取用户私密信息，如买入卖出等重要信息，还需要获取用户的SessionKey的，我们可以通过下面接口函数，弹出登录窗口，然后登录后，定位到对应的App应用页面，然后页面加载的时候，获取到对应的SessionKey、

 

 

 

 

        /// <summary>
        /// 判断是否顺利获取SessionKey
        /// </summary>
        /// <returns></returns>
        private string GetAuthorizeCode(string appKey)
        {
            string authorizeCode = "";
            FrmAuthorized dlg = new FrmAuthorized();
            dlg.AppKey = appkey;
            if (dlg.ShowDialog() == DialogResult.OK)
            {
                authorizeCode = dlg.AuthrizeCode;
            }
            if (string.IsNullOrEmpty(authorizeCode)) return null;

            string sessionKeyUrl = string.Format(TOP_AUTH_URL, authorizeCode);
            HttpHelper helper = new HttpHelper();
            string html = helper.GetHtml(sessionKeyUrl);
            //格式
            //top_appkey=1142&top_parameters=xxx&top_session=xxx&top_sign=xxx&encode=utf-8
            string reg = ".*?&top_session=(?<session>.*?)&top_sign";
            string sessionKey = CRegex.GetText(html, reg, 1);
            return sessionKey;

        } 

 最后我们看看其中获取已买记录的接口实现如下所示。

        private void TestBuyInfo()
        {
            if (string.IsNullOrEmpty(sessionKey))
            {
                sessionKey = GetAuthorizeCode(this.appkey);
            }

            //买入交易
            Console.WriteLine("买入交易");
            TradesBoughtGetRequest req = new TradesBoughtGetRequest();
            //req.Fields = "tid,title,price,type,num_iid,seller_nick,buyer_nick,status";
            req.Fields = "tid,title,price,type,num_iid,seller_nick,buyer_nick,status,receiver_state,receiver_city,receiver_district,receiver_address";
            req.PageNo = 1L;
            req.PageSize = 40L;
            TradesBoughtGetResponse rsp = myclient.Execute(req, sessionKey);
            if (rsp != null)
            {
                //Console.WriteLine(rsp.Trades.Count);
                //if (rsp.Trades.Count > 0)
                //{
                //    foreach (Trade item in rsp.Trades)
                //    {
                //        Console.WriteLine(ObjectToString(item));
                //    }
                //}
                this.winGridView1.DisplayColumns = req.Fields.Replace("_", "");//对应字段的属性没有“_”字符的
                this.winGridView1.DataSource = rsp.Trades;
            }

        } 

 以上利用了我的Winform分页控件进行数据展示，因此代码要简化一些，当然，也可以用DataGridView来进行数据显示，不过代码方面可能要多一些。

 

作者: 伍华聪 发表于 2012-02-10 07:36 原文链接

评论: 2　查看评论　发表评论

最新新闻：
· 苹果征集iPad 3发布会演示应用 重点是图形应用(2012-02-10 17:23)
· 京东商城涉足汽车销售 将上线售车频道(2012-02-10 17:21)
· 亚马逊新广告挑衅苹果：一个iPad可买三台kindle(2012-02-10 17:20)
· 动视暴雪确认今年第二季度推出《暗黑破坏神3》(2012-02-10 16:59)
· 官方承认 Google Bar 逆行倒施(2012-02-10 16:55)

编辑推荐：高级编程语言的发展历程

网站导航：博客园首页  我的园子  新闻  闪存  博问  知识库

]]>淘宝API开发系列---淘宝API的测试及使用http://www.cnblogs.com/wuhuacong/archive/2012/02/09/2344703.html伍华聪伍华聪Thu, 09 Feb 2012 15:55:00 GMThttp://www.cnblogs.com/wuhuacong/archive/2012/02/09/2344703.html

在很久之前，由于对淘宝的API开发比较感兴趣，写了几篇关于淘宝API开发方面的随笔《淘宝API开发系列--开篇概述》和《淘宝API开发系列--商家的绑定》等文章，近期由于一客户需要一些淘宝API的例子，而我原来开发的例子已经过去两年了，之前我是基于一个中间组件top4net来进行开发的，这个模块就是在淘宝API SDK的基础上做了一些封装，不过原来的例子确已经不能运行了。

因此重新捡起行头，继续研究有啥变化的地方，不过发现虽然时间过去已经快两年了，淘宝API的使用模式，一直没有变化过，可能变化的就是API的一些细微的地方吧，因此这次，就摒弃了中间组件的方式，就直接使用淘宝官方提供的taobao-sdk-net.zip(http://dl.open.taobao.com/sdk/taobao-sdk-net.zip) 来进行开发，发现其实模式一样，操作也差不多而已，但是处理起来的细节有很多不同的地方。

为了进行淘宝的API开发，首先我们需要做下面几件事情。

1）

开发者注册一个账号，

 

2）然后为每个淘宝应用注册一个应用程序键（App Key) 。

3）下载淘宝API的SDK并掌握基本的API基础知识和调用，具体可以参考论坛的信息（http://dev.open.taobao.com/bbs/forum.php ）里面的技术分享区等。

4）利用SDK接口和对象，传入AppKey或者必要的时候获取并传入SessionKey来进行程序开发。

5）利用淘宝平台的文档中心和API测试工具，对接口进行测试。从而了解返回信息，方便程序获取。

 

以上是一般淘宝API应用开发的关键流程，其中通过淘宝文档中心和API测试工具，进行概念了解和接口信息查询很重要。因为这些数据就是我们需要在逐步显示出来的。淘宝的API很多，不过都分为了好几个领域，慢慢就会了解深入了。

 

 

然后我们也可以通过淘宝平台的API测试工具来了解返回的数据信息，每个淘宝API最下面一般都有一个API工具的内容，如下所示。其中我们选择【API Tools在线测试工具】就可以测试返回的接口数据了。

 

 

 

对于以上这些淘宝API接口，不需要Session就可以访问的，就直接利用【系统分配】的内容就可以访问并获取到数据了。注意其中红色圈中部分即可。

对于有一些用户方面的私密数据，如交易数据，买入或者卖出的数据，我们就要自定义指定自己的SessionKey了，如下所示。

 

 

 卖出的信息，也需要传入SessionKey的信息，在程序中处理，得到下面的结果。

 

 

作者: 伍华聪 发表于 2012-02-09 23:55 原文链接

评论: 3　查看评论　发表评论

最新新闻：
· 苹果征集iPad 3发布会演示应用 重点是图形应用(2012-02-10 17:23)
· 京东商城涉足汽车销售 将上线售车频道(2012-02-10 17:21)
· 亚马逊新广告挑衅苹果：一个iPad可买三台kindle(2012-02-10 17:20)
· 动视暴雪确认今年第二季度推出《暗黑破坏神3》(2012-02-10 16:59)
· 官方承认 Google Bar 逆行倒施(2012-02-10 16:55)

编辑推荐：高级编程语言的发展历程

网站导航：博客园首页  我的园子  新闻  闪存  博问  知识库

]]>【翻译】C#编程语言和JAVA编程语言的比较（上）http://www.cnblogs.com/lovecindywang/archive/2012/02/09/2344315.htmllovecindywanglovecindywangThu, 09 Feb 2012 09:57:00 GMThttp://www.cnblogs.com/lovecindywang/archive/2012/02/09/2344315.html

原文地址：http://www.25hoursaday.com/CsharpVsJava.html

 

简介

 

C#语言是一门面向对象的语言，开发者可以使用C#和微软.NET平台快速构建各种应用程序。C#和.NET平台的目标是把开发者从一些诸如内存管理、类型安全问题、底层类库、数组边界检查等等的底层问题中解放出来并节约大量的时间，这样开发者就可以真正把时间和精力放在他们的应用程序和业务逻辑上。对于Java开发者来说，把前面那句话的开头改为“Java语言和平台”，这句话也同样可以总结Java语言和平台。

 

后面的内容介绍了C#和Java编程语言的异同，这些都是基于我使用两个语言的经历。所有代码都经过微软.NET框架2.0以及Java SE 6的测试。

 

注意：作者有些代码不符合.NET 3.5或JAVA SE 7（或以上）版本的最佳实践写法并且也不能覆盖它们所提供的新语法和新特性，但不影响本文的重点也就是平台的比较。

 

第一部分：C#和JAVA基本一致的地方

 

1、我们都是Object

 

C#的类层次中有一个根，也就是所有C#的类都是System.Object的子类，Java也是这样，所有类都是java.lang.Object的子类。两个语言的Object类的方法有些相同（比如System.Object的ToString()和java.lang.Object的toString()），也有一些不同（System.Object没有java.lang.Object中的wait()、notify()或notifyAll()）。

 

注意：在C#中object类可以写成object或Object。小写的object C#关键字在编译的时候会替换为System.Object。

 

2、关键字一览

 

Java和C#有很多语法很相似，除了throws、transient和strictfp几乎所有Java关键字都有C#的对应。下表示Java和C#的关键字对照表，Java关键字标红而C#关键字标蓝。

 

image

 

注意：尽管goto和const是Java语言的关键字，但是在Java中并没有用到。C#中的[NonSerialized]特性等价于Java中的transient关键字。

 

3、虚拟机和语言运行时

 

Java一般编译成Java字节码并运行于托管的执行环境（Java虚拟机、JVM），同样，C#代码编译成中间语言（IL）运行于公共语言运行时（CLR）。两个平台都通过JIT编译器提供本机编译。

 

注意：虽然Java平台支持字节码的解释和JIT编译两种方式，但是.NET平台只支持C#代码的本机执行，IL代码在运行前总是会编译成本机代码。

 

4、基于堆和垃圾收集

 

在Java中，对象使用new关键字创建在堆上。在C#中大多数类使用new关键字创建在堆上。和JVM一样，CLR也是通过标记和压缩垃圾回收算法管理销毁对象。

 

注意：C#还支持基于栈的类，叫做值类型，后文会介绍到这个。

 

5、数组可以是交错的

 

对于C或C++这样的语言，多维数组的每一个子数组都必须有相同的维度。在Java和C#中数组不必统一，交错数组可以认为是数组的一维数组。交错数组的项就是保持类型或引用的另一个数组，这样交错数组的行和列就不需要有统一的长度，如下代码所示：

 

int [][]myArray = new int[2][]; 
  myArray[0] = new int[3]; 
  myArray[1] = new int[9];

6、没有全局方法

 

和Java一样，和C++不一样，C#中的方法必须是类的一部分，作为成员方法或静态方法。

 

7、有接口但没有多重继承

 

C#和Java一样支持接口的概念，接口类似纯抽象类。C#和Java一样都支持类的单继承，但支持借口的多重继承（或实现）。

 

8、字符串不可变

 

C#的System.String类和java.lang.String类相似。它们都是不可变的，也就是字符串的值在创建后一次都不能修改。字符串提供的一些实例方法看似可以修改字符串的内容，其实是创建了一个新的字符串并返回，原始的字符串并没有修改。如下的C#和Java代码都没有修改字符串：

 

C# Code
   String csString = "Apple Jack"; 
   csString.ToLower(); 
Java Code
   String jString = "Grapes"; 
   jString.toLowerCase();

 

9、密封类

 

Java和C#都提供了一种机制确保类是继承体系中的最后一个，不可以有子类。在Java中可以为类修饰final关键字，而C#则通过sealed关键字修饰类。如下是两种语言密封类的例子：

C# Code
 sealed class Student {
   string fname;
   string lname;
   int uid;
   void attendClass() {}
} 

Java Code
 final class Student {
   String fname;
   String lname;
   int uid;
   void attendClass() {}
}

 

10、抛出和捕获异常

 

C#和Java的异常有很多相似的地方。两种语言都使用try块来表示需要守护的区域，catch块来处理抛出的异常，finally块在离开方法之前释放资源。两种语言都有继承体系，所有的异常都从一个Exception类继承。并且都可以在捕获到异常并进行了一些错误处理之后重新抛出异常。最后，它们都提供了机制把异常包装成另外一个异常，这样就可以捕获到一个异常后抛出另一个异常。这里可以举一个例子，比如三层结构的应用程序，数据访问的时候捕获到了一个SQLException，可以抛出一个应用程序相关的异常。这样的话，应用程序异常可以使用原始的SQLException来初始化，处理应用程序异常的时候如果需要还可以访问到原始的异常。如下代码演示了两种语言在异常方面的相似：

C# Code
using System;
using System.IO; 

class MyException: Exception{

  public MyException(string message): base(message){ }

  public MyException(string message, Exception innerException): 
    base(message, innerException){ }


}

public class ExceptionTest {
    
    
    static void DoStuff(){  
    throw new FileNotFoundException();  
    }
    
    
    public static void Main(string[] args){

    try{            

        try{        
        
        DoStuff(); 
        return;  //won't get to execute 

        }catch(IOException ioe){ /* parent of FileNotFoundException */ 
        
        throw new MyException("MyException occured", ioe); /* rethrow new exception with inner exception specified */
        }
        
    }finally{
        
        Console.WriteLine("***Finally block executes even though MyException not caught***");
    
    }
    
}//Main(string[])

} // ExceptionTest

Java Code

class MyException extends Exception{

    public MyException(String message){ super(message); }
    
    public MyException(String message, Exception innerException){ super(message, innerException); }


}

public class ExceptionTest {
    
    
    static void doStuff(){  
    throw new ArithmeticException();    
    }
    
    
    public static void main(String[] args) throws Exception{
    
    try{            
        
        try{        
        
        doStuff(); 
        return;  //won't get to execute 
        
        }catch(RuntimeException re){ /* parent of ArithmeticException */ 
        
        throw new MyException("MyException occured", re); /* rethrow new exception with cause specified */
        }
        
    }finally{
        
        System.out.println("***Finally block executes even though MyException not caught***");
    
    }
    
}//main(string[])

} // ExceptionTest

 

11、定义的时候进行成员初始化和静态构造方法

 

C#和Java中都可以在定义实例和静态变量的时候进行初始化。如果成员变量是实例变量则在构造方法执行之前调用，静态成员则在第一次使用成员以及第一次创建类实例之前初始化。还可以指定一段代码在类创建之前或静态方法调用之前被调用。这段代码在C中叫做静态构造方法而在Java中叫做静态初始化块。静态构造方法会在第一次调用类的静态方法或第一次创建类实例之前调用。

 

using System; 

class StaticInitTest{


    string instMember = InitInstance(); 

    static string staMember = InitStatic(); 
    

    StaticInitTest(){
    Console.WriteLine("In instance constructor");
    }

    static StaticInitTest(){
    Console.WriteLine("In static constructor");
    }


    static String InitInstance(){
    Console.WriteLine("Initializing instance variable");
    return "instance";
    }

     static String InitStatic(){
    Console.WriteLine("Initializing static variable");
    return "static";
    }


    static void DoStuff(){
    Console.WriteLine("Invoking static DoStuff() method");
    }

    
    public static void Main(string[] args){

    Console.WriteLine("Beginning main()");

    StaticInitTest.DoStuff(); 
    
    StaticInitTest sti = new StaticInitTest(); 

    Console.WriteLine("Completed main()");

    }

}
class Main{


    String instMember = initInstance(); 

    static String staMember = initStatic(); 
    

    Main(){
    System.out.println("In instance constructor");
    }

    static{
    System.out.println("In static constructor");
    }


    static String initInstance(){
    System.out.println("Initializing instance variable");
    return "instance";
    }

     static String initStatic(){
    System.out.println("Initializing static variable");
    return "static";
    }


    static void doStuff(){
    System.out.println("Invoking static DoStuff() method");
    }

    
    public static void main(String[] args){

    System.out.println("Beginning main()");

    Main.doStuff(); 
    
    Main sti = new Main(); 

    System.out.println("Completed main()");

    }

}

 

代码执行结果：

Initializing static variable
In static constructor
Beginning main()
Invoking static DoStuff() method
Initializing instance variable
In instance constructor
Completed main()

 

注意：这里作者的代码有误，小小修改了一下

 

12、装箱

 

在某些情况下，值类型需要当做对象，.NET和Java运行时会自动把值类型转换成在堆上分配的引用类型，这个过程叫做装箱。自动把对象转换成相应的值类型的过程叫做拆箱，比如把java.lang.Integer的实例转换成int。如下例子演示了运行时发生装箱的各种情况：

 

C# Code
using System; 
using System.Collections;

//分配在栈上的结构需要装箱才能当做object
struct Point{

  //member fields 
    private int x; 
    private int y; 

    public Point (int x, int y){
  
    this.x = x;
    this.y = y; 

    } 
    
    public override string ToString(){

    return String.Format("({0}, {1})", x, y); 

    }


}//Point

class Test{


     public static void PrintString(object o){

     Console.WriteLine(o);

     }

     public static void Main(string[] args){

       Point p = new Point(10, 15); 
       ArrayList list = new ArrayList(); 
       int z = 100;

       PrintString(p); //p在传参的时候装箱了
       PrintString(z); //z在传参的时候装箱了

       // 在保存到集合的时候int和float装箱了
       // 不需要Java的包装类 
       list.Add(1); 
       list.Add(13.12); 
       list.Add(z); 
       
       for(int i =0; i < list.Count; i++)
       PrintString(list[i]);    
       
     }

}
Java Code
import java.util.*;

class Test{

public static void PrintString(Object o){

 System.out.println(o);

}

public static void PrintInt(int i){

 System.out.println(i); 
  
}

public static void main(String[] args){

 Vector list = new Vector(); 
 int z = 100;
 Integer x = new Integer(300);
 PrintString(z); //z boxed to object when passed to PrintString
 PrintInt(x); //x unboxed to int when passed to PrintInt

 // integers and float boxed when stored in collection 
 // therefore no need for Java wrapper classes 
 list.add(1); 
 list.add(13.12); 
 list.add(z); 
       
 for(int i =0; i < list.size(); i++)
   PrintString(list.elementAt(i));    
       
}

}

 

第二部分：C#和JAVA基本一致但语法不同的地方

1、Main方法

 

C#和Java程序的入口点都是main方法。表面区别是C#的Main方法是大写的M（.NET框架的方法名的惯例），而Java中的main方法是小写字母m（同样也是Java方法的惯例）。还有一个区别就是C#的Main()方法可以没有参数。

 

C# Code
 using System; 

 class A{
   
   public static void Main(String[] args){
   
     Console.WriteLine("Hello World"); 
   
   }
} 

Java Code
 class B{
   
   public static void main(String[] args){
   
     System.out.println("Hello World"); 
   
   }
}

 

一般推荐应用程序的每一个类都有一个main方法来测试类的功能，比如可能有两个类A和B都包含main方法。在Java中，类是编译的单元，只需要通过命令行指定需要运行的类，在C#中也可以使用/main开关编译应用程序指定应用程序创建时使用哪个main作为入口点实现相同的效果。使用main以及预处理指令条件编译是不错的测试技术。

 

Java Example
C:\CodeSample> javac A.java B.java 

C:\CodeSample> java A
 Hello World from class A

C:\CodeSample> java B
 Hello World from class B

C# Example
C:\CodeSample> csc /main:A /out:example.exe A.cs B.cs 

C:\CodeSample> example.exe
 Hello World from class A

C:\CodeSample> csc /main:B /out:example.exe A.cs B.cs 

C:\CodeSample> example.exe
 Hello World from class B


对于Java，改变使用的main不需要进行重新编译，而C#应用程序需要重新编译。但是，从另一方面来说，Java又不支持条件编译，main方法可能就会带入发行版本中。

 

2、继承语法

 

C#对于继承使用了C++的语法，都使用冒号来实现继承和接口实现，在Java中则是extends和implements关键字。

 

C# Code
 using System;

 class B:A, IComparable{
   
  int CompareTo(){}

   public static void Main(String[] args){
   
     Console.WriteLine("Hello World"); 
   
   }
} 

Java Code
 class B extends A implements Comparable{
   
   int compareTo(){}

   public static void main(String[] args){
   
     System.out.println("Hello World"); 
   
   }
}

 

C#的这种语法更符合从C++转来开发者的习惯，而Java的语法则可以通过类的声明直接知道类是子类呢还是只是实现了接口，C#则无法区分。但是我们知道根据.NET的命名约定，接口需要以大写的字母I打头，比如ICloneable，这样就不会有这个问题了。

 

3、运行时类型标识（is操作符）

 

C#的js操作符和Java的instanceof操作符一样。如下代码等价：

C# Code

  if(x is MyClass)
   MyClass mc = (MyClass) x;

Java Code

  if(x instanceof MyClass)
   MyClass mc = (MyClass) x;

 

4、命名空间

 

C#命名空间是对类进行分组的方式，和Java的包构造差不多。使用C++的人会发现C#命名空间和C++的差不多，在Java中，包名字代笔应用程序中源文件目录结构，而C#的命名空间则不会要求源文件的物理层次和逻辑结构有关联：

 

C# Code

  namespace com.carnage4life{

   public class MyClass {
 
   int x; 

   void doStuff(){}

   }

 }

Java Code
  package com.carnage4life;

  public class MyClass {
 
  int x; 

  void doStuff(){}

 }

C#的命名空间语法允许进行命名空间的嵌套，如下：

 

C# Code
  using System;

  namespace Company{
    
    public class MyClass { /* Company.MyClass */ 
 
        int x; 

        void doStuff(){}

        } 

    namespace Carnage4life{
    
       public class MyOtherClass {  /* Company.Carnage4life.MyOtherClass */ 
 
        int y; 

        void doOtherStuff(){}
    
       public static void Main(string[] args){
    
        Console.WriteLine("Hey, I can nest namespaces"); 
       }

      }// class MyOtherClass
       }// namespace Carnage4life
   }// namespace Company

 

5、构造方法、析构方法以及终结器

 

C#中的构造方法的语法和语义和Java一样。C#还有析构方法的概念，这和C++的析构器语法比较相似，和Java的终结器语义一致。尽管存在析构方法这样的语法，但是还是不推荐使用，有许多原因。首先我们没有办法控制它运行的时间，如果在析构方法里面还持有其它引用的话情况更复杂，其次还会带来性能问题，因为垃圾回收线程不能直接回收带有析构方法的对象，必须等到终结器线程执行之后才可以回收，这样具有析构方法的对象可能比没有析构方法的对象存在的时间更长。如下是C#和Java的例子：

C# Code
using System; 

  public class MyClass {
 
     static int num_created = 0; 
     int i = 0;    

      MyClass(){  
        i = ++num_created; 
        Console.WriteLine("Created object #" + i);    
     }

     ~MyClass(){
         Console.WriteLine("Object #" + i + " is being finalized");  
     }

    public static void Main(string[] args){

    for(int i=0; i < 10000; i++)
      new MyClass(); 
    
    }

   }

Java Code
  public class MyClass {
 
     static int num_created = 0; 
     int i = 0;    

      MyClass(){  
        i = ++num_created; 
        System.out.println("Created object #" + i);    
     }

     public void finalize(){
        System.out.println("Object #" + i + " is being finalized");  
     }

    public static void main(String[] args){

    for(int i=0; i < 10000; i++)
      new MyClass(); 
    
    }

   }

 

注意：在C#中析构方法（终结器）会在执行后自动调用基类的终结器，Java中不会。

 

6、同步方法和代码块

 

在Java中可以指定同步块来确保在同一时刻只有一个线程访问某个对象，C#提供了lock语句对应Java的synchronized语句。

 

C# Code

 public void WithdrawAmount(int num){ 

   lock(this){ 

   if(num < this.amount)
     this.amount -= num; 

   }

 }

Java Code

  public void withdrawAmount(int num){ 

   synchronized(this){ 

   if(num < this.amount)
     this.amount -= num; 

   }

 }

C#和Java都有同步方法的概念。在调用同步方法的时候，调用方法的线程会锁定包含方法的对象，因此其它线程调用相同对象的同步方法必须等到其它线程执行完方法释放锁之后才能执行。同步方法在Java中用synchronized关键字来标记，而在C#中使用[MethodImpl(MethodImplOptions.Synchronized)]特性来修饰。同步方法的例子如下：

C# Code
using System;
using System.Runtime.CompilerServices;

public class BankAccount{

 [MethodImpl(MethodImplOptions.Synchronized)]
 public void WithdrawAmount(int num){ 

   if(num < this.amount)
     this.amount - num; 

 }

}//BankAccount

Java Code

public class BankAccount{

  public synchronized void withdrawAmount(int num){ 

   if(num < this.amount)
     this.amount - num; 

 }

}//BankAccount

 

7、访问修饰符

 

如下表格对照C#和Java的访问修饰符。C++爱好者比较失望，在Java2中Sun改变了protected关键字的语义，而C#的protected关键字和C++的一样。也就是说，protected成员只有在类的成员方法或派生类的成员方法中可以访问。internal修饰符表示成员可以被类相同程序集的其它类访问。internal protected修饰符表示的是internal或protected。

image

注意：在没有指定访问修饰符的情况下，C#字段或方法的默认访问级别是private，而Java则是protected。

 

8、反射

 

在C#和Java中发现类中方法和字段以及运行时调用类方法的能力一般叫做反射。Java和C#中反射的主要区别是，C#的反射是程序集级别的，而Java是类级别的。由于程序集一般保存为DLL，对于C#需要包含类的DLL，而Java需要可以加载类文件或目标类。如下例子遍历某个类的方法，以此比较C#和Java在反射上的差异：

 

C# Code

using System; 
using System.Xml; 
using System.Reflection;
using System.IO; 

class ReflectionSample {

   
    public static void Main( string[] args){


    Assembly assembly=null;
    Type type=null;
    XmlDocument doc=null; 

    try{
        // 加载程序集以获得类型
        assembly = Assembly.LoadFrom("C:\\WINNT\\Microsoft.NET\\Framework\\v1.0.2914\\System.XML.dll");
        type = assembly.GetType("System.Xml.XmlDocument", true);

        //Unfortunately one cannot dynamically instantiate types via the Type object in C#. 
        doc  =  Activator.CreateInstance("System.Xml","System.Xml.XmlDocument").Unwrap() as XmlDocument;

          if(doc != null)
                 Console.WriteLine(doc.GetType() + " was created at runtime");
              else
                 Console.WriteLine("Could not dynamically create object at runtime");

    }catch(FileNotFoundException){
        Console.WriteLine("Could not load Assembly: system.xml.dll");
         return;
    }catch(TypeLoadException){
        Console.WriteLine("Could not load Type: System.Xml.XmlDocument from assembly: system.xml.dll");
        
        return;
    }catch(MissingMethodException){
       Console.WriteLine("Cannot find default constructor of " + type);
       }catch(MemberAccessException){
       Console.WriteLine("Could not create new XmlDocument instance");
       }
    
    // 获得方法
    MethodInfo[] methods = type.GetMethods();
        
    //打印方法签名和参数
    for(int i=0; i < methods.Length; i++){
    
        Console.WriteLine ("{0}", methods[i]);
        
        ParameterInfo[] parameters = methods[i].GetParameters(); 
        
        for(int j=0; j < parameters.Length; j++){   
        Console.WriteLine (" Parameter: {0} {1}", parameters[j].ParameterType, parameters[j].Name);
        }
        
    }//for (int i...) 
    
    }

}

 

上面的代码可以看到C#的反射API略微优雅一点，C#提供了ParameterInfo包含方法的参数元数据，而Java提供的只是Class对象丢失了诸如参数名等信息。

有的时候需要获取指定类元数据对象，那么可以使用Java的java.lang.Class或C#的System.Type对象。要从类的实例获取元数据，在Java中可以使用getClass()方法而在C#中可以使用GetType()方法。如果要根据名字而不是创建一个类的实例来获取元数据可以这么做：

C# Code
  
   Type t = typeof(ArrayList);

Java Code

   Class c = java.util.Arraylist.class; /* 必须在类的完整名字后跟 .class */

9、声明常量

 

在Java中要声明常量可以使用final关键字。final的变量可以在编译时或运行时进行设置。在Java中，如果在基元上使用final的话基元的值不可变，如果在对象引用上使用final的话，则引用只可以指向一个对象。final的成员可以在声明的时候不初始化，但是必须要构造方法中初始化。

 

在C#中要声明常量使用const关键字来表示编译时常量，使用readonly关键字来表示运行时常量。基元常量和引用常量的语义对于C#和Java来说是一样的。

和C++不同的是，C#和Java不能通过语言结构来指定不可变的类。

 

C# Code

using System; 

public class ConstantTest{
    
    /* 编译时常量*/ 
    const int i1 = 10;   //隐含表示这是static的变量
    
    // 下面的代码不能通过编译
    // public static const int i2 = 20; 

    /* 运行时常量 */
    public static readonly uint l1 =  (uint) DateTime.Now.Ticks;
  
    /* 对象引用作为常量 */ 
    readonly Object o = new Object();
 
    /* 未初始化的只读变量 */ 
    readonly float f; 

  
    ConstantTest() {
    // 未初始化的只读变量必须在构造方法中初始化
    f = 17.21f; 
    }
  
}

Java Code

import java.util.*; 

public class ConstantTest{
    
    /* Compile time constants */ 
    final int i1 = 10;   //instance variable 
    static final int i2 = 20; //class variable 

    /* run time constants */
    public static final long l1 = new Date().getTime();
  
    /* object reference as constant */ 
    final Vector v = new Vector();
 
    /* uninitialized final */ 
    final float f; 

  
    ConstantTest() {
    // unitialized final variable must be initialized in constructor 
    f = 17.21f; 
    }
  
}

注意：Java语言还支持方法上的final参数。在C#中没有这个功能。final参数只要用于允许传入方法的参数可以让方法内的内部类进行访问。

 

10、基元类型

 

对于Java中的每一个基元类型在C#中都有同名的对应（除了byte之外）。Java中的byte是有符号的，等价于C#中的sbyte，不同于C#的byte。C#还提供了一些基元类型的无符号版本，比如ulong、uint、ushort和byte。C#中最不同的基元类型是decimal类型，不会有舍入错误，当然也就需要更多空间也更慢。

C# Code

  decimal dec = 100.44m; //m is the suffix used to specify decimal numbers
  double  dbl = 1.44e2d; //e is used to specify exponential notation while d is the suffix used for doubles

11、数组声明

 

Java有两种方式声明数组。一种方式为了兼容C/C++的写法，另外一种更具有可读性，C#只能使用后者。

C# Code

  int[] iArray = new int[100]; //valid, iArray is an object of type int[] 
  float fArray[] = new float[100]; //ERROR: Won't compile  

Java Code

  int[] iArray = new int[100]; //valid, iArray is an object of type int[] 
  float fArray[] = new float[100]; //valid, but isn't clear that fArray is an object of type float[]

12、调用基类构造方法和构造方法链

 

C#和Java自动调用基类构造方法，并且提供了一种方式可以调用基类的有参构造方法。两种语言都要求派生类的构造方法在任何初始化之前先调用基类的构造方法防止使用没有初始化的成员。两种语言还提供了在一个构造方法中调用另一个构造方法的方式以减少构造方法中代码的重复。这种方式叫做构造方法链：

 

C# Code

using System; 

class MyException: Exception
{

  private int Id; 

  public MyException(string message): this(message, null, 100){ }

  public MyException(string message, Exception innerException): 
    this(message, innerException, 100){ }

  public MyException(string message, Exception innerException, int id):
    base(message, innerException){
    
    this.Id = id;   
  }

}
  
Java Code


class MyException extends Exception{

    private int Id; 
    

    public MyException(String message){
    
    this(message, null, 100); 
    }

    public MyException(String message, Exception innerException){
    
    this(message, innerException, 100); 
    
    }

  public MyException( String message,Exception innerException, int id){
      
      super(message, innerException); 
      this.Id = id;     

  }
}

 

13、可变长度参数列表

 

在C和C++中可以指定函数接收一组参数。在printf和scanf类似的函数中大量使用这种特性。C#和Java允许我们定义一个参数接收可变数量的参数。在C#中可以在方法的最后一个参数上使用params关键字以及一个数组参数来实现，在Java中可以为类型名通过增加三个.来实现。

C# Code
using System;

class ParamsTest{

    public static void PrintInts(string title, params int[] args){

    Console.WriteLine(title + ":");

    foreach(int num in args)
        Console.WriteLine(num); 

    }


    public static void Main(string[] args){

    PrintInts("First Ten Numbers in Fibonacci Sequence", 0, 1, 1, 2, 3, 5, 8, 13, 21, 34);
    }

}
Java Code
class Test{

    public static void PrintInts(String title, Integer... args){

    System.out.println(title + ":");

    for(int num : args)
        System.out.println(num); 

    }

    public static void main(String[] args){

    PrintInts("First Ten Numbers in Fibonacci Sequence", 0, 1, 1, 2, 3, 5, 8, 13, 21, 34);
    }

}

 

14、泛型

 

C#和Java都提供了创建强类型数据结构且不需要在编译时知道具体类型的机制。在泛型机制出现以前，这个特性通过在数据结构中指定object类型并且在运行时转换成具体类型来实现。但是这种技术有许多缺点，包括缺乏类型安全、性能不佳以及代码膨胀。

如下代码演示了两种方式：

# Code
using System;
using System.Collections;
using System.Collections.Generic; 

class Test{

    public static Stack GetStackB4Generics(){
    Stack s = new Stack(); 
    s.Push(2);
    s.Push(4); 
    s.Push(5);

    return s;
    }

    public static Stack<int> GetStackAfterGenerics(){
    Stack<int> s = new Stack<int>(); 
    s.Push(12);
    s.Push(14); 
    s.Push(50);

    return s;
    }

    public static void Main(String[] args){

    Stack s1 = GetStackB4Generics(); 
    int sum1 = 0; 
    
    while(s1.Count != 0){
        sum1 += (int) s1.Pop(); //cast 
    }
    
    Console.WriteLine("Sum of stack 1 is " + sum1); 

    Stack<int> s2 = GetStackAfterGenerics(); 
    int sum2 = 0; 
    
    while(s2.Count != 0){
        sum2 += s2.Pop(); //no cast
    }
    
    Console.WriteLine("Sum of stack 2 is " + sum2); 
    }

}
Java Code
import java.util.*; 

class Test{

    public static Stack GetStackB4Generics(){
    Stack s = new Stack(); 
    s.push(2);
    s.push(4); 
    s.push(5);

    return s;
    }

    public static Stack<Integer> GetStackAfterGenerics(){
    Stack<Integer> s = new Stack<Integer>(); 
    s.push(12);
    s.push(14); 
    s.push(50);

    return s;
    }

    public static void main(String[] args){

    Stack s1 = GetStackB4Generics(); 
    int sum1 = 0; 
    
    while(!s1.empty()){
        sum1 += (Integer) s1.pop(); //cast 
    }
    
    System.out.println("Sum of stack 1 is " + sum1); 

    Stack<Integer> s2 = GetStackAfterGenerics(); 
    int sum2 = 0; 
    
    while(!s2.empty()){
        sum2 += s2.pop(); //no cast
    }
    
    System.out.println("Sum of stack 2 is " + sum2); 
    }

}

尽管和C++中的模板概念相似，C#和Java中的泛型特性实现上不一样。在Java中，泛型功能使用类型擦除来实现。泛型信息只是在编译的时候出现，编译后被编译器擦除所有类型声明替换为Object。编译器自动在核实的地方插入转换语句。这么做的原因是，泛型代码和不支持泛型的遗留代码可以互操作。类型擦除的泛型类型的主要问题是，泛型类型信息在运行时通过反射或运行时类型标识不可用。并且对于这种方式，泛型类型数据结构必须使用对象和非基元类型进行生命。所以只能有Stack<Integer>而不是Stack<int>。

在C#中，.NET运行时中间语言IL直接支持泛型。泛型在编译的时候，生成的IL包含具体类型的占位符。在运行的时候，如果初始化一个泛型类型的引用，系统会看是否有人已经用过这个类型了，如果类型之前请求过则返回之前生成的具体类型，如果没有JIT编译器把泛型参数替换为IL中的具体类型然后再初始化新的类型。如果请求的类型是引用类型而不是值类型的话，泛型类型参数会替换为Object，但是不需要进行转换，因为.NET运行时会在访问的时候内部进行转换。

 

在某些时候，我们的方法需要操作包含任意类型的数据结构而不是某个具体类型，但是又希望利用强类型泛型的优势。这个时候我们可以通过C#的泛型类型推断或Java通配类型实现。如下代码所示：

C# Code
using System;
using System.Collections;
using System.Collections.Generic; 

class Test{

    //Prints the contents of any generic Stack by 
    //using generic type inference 
    public static void PrintStackContents<T>(Stack<T> s){
    while(s.Count != 0){
        Console.WriteLine(s.Pop()); 
    }    
    }

    public static void Main(String[] args){

    Stack<int> s2 = new Stack<int>(); 
    s2.Push(4); 
    s2.Push(5); 
    s2.Push(6); 

    PrintStackContents(s2);     
    
    Stack<string> s1 = new Stack<string>(); 
    s1.Push("One"); 
    s1.Push("Two"); 
    s1.Push("Three"); 

    PrintStackContents(s1); 
    }

}
Java Code
import java.util.*; 

class Test{

    //Prints the contents of any generic Stack by 
    //specifying wildcard type 
    public static void PrintStackContents(Stack<?> s){
    while(!s.empty()){
        System.out.println(s.pop()); 
    }    
    }

    public static void main(String[] args){

    Stack <Integer> s2 = new Stack <Integer>(); 
    s2.push(4); 
    s2.push(5); 
    s2.push(6); 

    PrintStackContents(s2);     
    
    Stack<String> s1 = new Stack<String>(); 
    s1.push("One"); 
    s1.push("Two"); 
    s1.push("Three"); 

    PrintStackContents(s1); 
    }

}

C#和Java都提供了泛型约束。对于C#有三种类型的约束：

1）派生约束，告诉编译器泛型类型参数需要从某个基类型继承，比如接口或基类

2）默认构造方法约束，告诉编译器泛型类型参数需要提供公共的默认构造方法

3）引用、值类型约束，泛型类型参数需要是引用类型或值类型

对于Java支持派生约束：

C# Code
using System;
using System.Collections;
using System.Collections.Generic; 

public class Mammal {
    public Mammal(){;}

    public virtual void Speak(){;} 
}

public class Cat : Mammal{
    public Cat(){;}

    public override void Speak(){
    Console.WriteLine("Meow");
    }
}

public class Dog : Mammal{
    public Dog(){;}

    public override void Speak(){
    Console.WriteLine("Woof");
    } 
}


public class MammalHelper<T> where T: Mammal /* derivation constraint */,
                                   new() /* default constructor constraint */{ 

    public static T CreatePet(){
    return new T(); 
    }

    
    public static void AnnoyNeighbors(Stack<T> pets){
    while(pets.Count != 0){
        Mammal m = pets.Pop(); 
        m.Speak();  
    }    
    }  
}

public class Test{

 public static void Main(String[] args){

    Stack<Mammal> s2 = new Stack<Mammal>(); 
    s2.Push(MammalHelper<Dog>.CreatePet()); 
    s2.Push(MammalHelper<Cat>.CreatePet()); 

    MammalHelper<Mammal>.AnnoyNeighbors(s2);         
    }
}
Java Code
import java.util.*; 

abstract class Mammal {
    public abstract void speak(); 
}

class Cat extends Mammal{
    public void speak(){
    System.out.println("Meow");
    }
}

class Dog extends Mammal{
    public void speak(){
    System.out.println("Woof");
    } 
}

public class Test{
    
    //derivation constraint applied to pets parameter
    public static void AnnoyNeighbors(Stack<? extends Mammal> pets){
    while(!pets.empty()){
        Mammal m = pets.pop(); 
        m.speak();  
    }    
    }

    public static void main(String[] args){

    Stack<Mammal> s2 = new Stack<Mammal>(); 
    s2.push(new Dog()); 
    s2.push(new Cat()); 

    AnnoyNeighbors(s2);         
    }
}

C#还提供了default操作符可以返回类型的默认值。引用类型的默认值是null，值类型（比如int、枚举和结构）的默认值是0（0填充结构）。对于泛型default很有用，如下代码演示了这个操作符的作用：

C# Code
using System;

public class Test{

    public static T GetDefaultForType<T>(){
    return default(T); //return default value of type T
    }

    public static void Main(String[] args){
    
    Console.WriteLine(GetDefaultForType<int>());
    Console.WriteLine(GetDefaultForType<string>());    
    Console.WriteLine(GetDefaultForType<float>());

    }
}

输出：

0

 

0

 

15、for-each循环

 

for-each循环是很多脚本语言、编译工具、方法类库中非常常见的一种迭代结构。for-each循环简化了C#中实现System.Collections.IEnumerable接口或Java中java.lang.Iterable接口数组或类的迭代。

在C#中通过foreach关键字来创建for-each循环，而在Java中通过操作符:来实现。

C# Code
string[] greek_alphabet = {"alpha", "beta", "gamma", "delta", "epsilon"};

foreach(string str in greek_alphabet)
  Console.WriteLine(str + " is a letter of the greek alphabet");

Java Code
String[] greek_alphabet = {"alpha", "beta", "gamma", "delta", "epsilon"};

for(String str : greek_alphabet)
  System.out.println(str + " is a letter of the greek alphabet");

 

16、元数据注解

 

元数据注解提供了一种强大的方式来扩展编程语言和语言运行时的能力。注解是可以要求运行时进行一些额外任务、提供类额外信息扩展功能的一些指令。元数据注解在许多编程环境中很常见，比如微软的COM和linux内核。

C#特性提供了为模块、类型、方法或成员变量增加注解的方式。如下描述了一些.NET自带的特性以及如何使用它们来扩展C#的能力：

 

1）[MethodImpl(MethodImplOptions.Synchronized)] 用于指定多线程访问方法的时候使用锁进行保护，和Java的sychronized一样。

2）[Serializable]用于把类标记为可序列化的，和Java的实现Serializable接口相似。

3）[FlagsAttribute]用于指定枚举支持位操作。这样枚举就可以有多个值。

C# Code
   //declaration of bit field enumeration 
   [Flags]
   enum ProgrammingLanguages{ 
   C     = 1, 
   Lisp  = 2, 
   Basic = 4, 
   All  = C | Lisp | Basic
   }

  aProgrammer.KnownLanguages  =  ProgrammingLanguages.Lisp; //set known languages  ="Lisp"
  aProgrammer.KnownLanguages |=  ProgrammingLanguages.C; //set known languages  ="Lisp C"
  aProgrammer.KnownLanguages &= ~ProgrammingLanguages.Lisp; //set known languages  ="C"

  if((aProgrammer.KnownLanguages & ProgrammingLanguages.C) > 0){ //if programmer knows C
    //.. do something 
  }

4）[WebMethod]在ASP.NET中用于指定方法可以通过Web服务访问。

可以通过反射来访问模块、类、方法或字段的特性（详见http://msdn.microsoft.com/zh-cn/library/system.attributetargets.aspx）。对于运行时获取类是否支持某个行为特别有用，开发者可以通过继承System.Attribute类来创建他们自己的特性。如下是使用特性来提供类作者信息的例子，然后我们通过反射来读取这个信息。

C# Code
using System; 
using System.Reflection;
[AttributeUsage(AttributeTargets.Class)]
public class AuthorInfoAttribute: System.Attribute{

    string author; 
    string email; 
    string version;


    public AuthorInfoAttribute(string author, string email){

    this.author = author; 
    this.email  = email;
    
    }


    public string Version{


    get{
        return version;
    }

    set{
        version = value; 
    }

    }


    public string Email{


    get{
        return email;
    }

    }

     public string Author{


    get{
        return author;
    }

    }

}



[AuthorInfo("Dare Obasanjo", "kpako@yahoo.com", Version="1.0")]
class HelloWorld{

}

class AttributeTest{

    public static void Main(string[] args){

    /* Get Type object of HelloWorld class */      
    Type t = typeof(HelloWorld); 

    Console.WriteLine("Author Information for " + t);
    Console.WriteLine("=================================");

    foreach(AuthorInfoAttribute att in t.GetCustomAttributes(typeof(AuthorInfoAttribute), false)){

        Console.WriteLine("Author: " + att.Author);
        Console.WriteLine("Email: " + att.Email);
        Console.WriteLine("Version: " + att.Version);   

    }//foreach

    }//Main

}

 

Java的提供了为包、类型、方法、参数、成员或局部变量增加注解的能力。Java语言只内置了三种注解，如下：

1）@Override用于指定方法覆盖基类的方法。如果注解的方法并没有覆盖基类的方法，在编译的时候会出错。

2）@Deprecated用于指示某个方法已经废弃。使用废弃的方法会在编译的时候产生警告。

3）@SuppressWarnings用于防止编译器发出某个警告。这个注解可选接收参数来表明屏蔽哪种警告。

 

和C#一样，可以通过反射来读取模块、类、方法或字段的注解。但是不同的是Java注解可以是元注解。开发者可以创建自定义的注解，创建方法和接口相似，只不过需要定义@interface关键字。如下是使用注解和通过反射读取信息的例子：

Java Code
import java.lang.annotation.*;
import java.lang.reflect.*;

@Documented //we want the annotation to show up in the Javadocs 
@Retention(RetentionPolicy.RUNTIME) //we want annotation metadata to be exposed at runtime
@interface AuthorInfo{
    String author(); 
    String email(); 
    String version() default "1.0";
}

@AuthorInfo(author="Dare Obasanjo", email="kpako@yahoo.com")
class HelloWorld{

}

public class Test{

    public static void main(String[] args) throws Exception{

    /* Get Class object of HelloWorld class */      
    Class c = Class.forName("HelloWorld");
    AuthorInfo a = (AuthorInfo) c.getAnnotation(AuthorInfo.class); 
    
    System.out.println("Author Information for " + c);
    System.out.println("=======================================");
    System.out.println("Author: " + a.author());
    System.out.println("Email: " + a.email());
    System.out.println("Version: " + a.version());      

    }
}

 

17、枚举

 

枚举用于创建一组用于自定义的命名常量。尽管从表面上看C#和Java的枚举非常相同，但是在实现上它们完全不同。Java的枚举类型是纯种的类，也就是它们是类型安全并可以增加方法、字段或甚至实现接口进行扩展，而在C#中枚举纯粹是一个包装了数字类型（一般是int）的语法糖，并且不是类型安全的。如下代码演示了两者的区别：

C# Code
using System;

public enum DaysOfWeek{
    SUNDAY, 
    MONDAY, 
    TUESDAY, 
    WEDNESDAY,
    THURSDAY, 
    FRIDAY,
    SATURDAY
}

public class Test{

    public static bool isWeekDay(DaysOfWeek day){
    return !isWeekEnd(day);   
    }

    public static bool isWeekEnd(DaysOfWeek day){
    return (day == DaysOfWeek.SUNDAY || day == DaysOfWeek.SATURDAY); 
    }

    public static void Main(String[] args){

    DaysOfWeek sun = DaysOfWeek.SUNDAY; 
    Console.WriteLine("Is " + sun + " a weekend? " + isWeekEnd(sun));
    Console.WriteLine("Is " + sun + " a week day? " + isWeekDay(sun));

    /* Example of how C# enums are not type safe */
    sun = (DaysOfWeek) 1999;
    Console.WriteLine(sun);
    
    }
}

 

Java Code
enum DaysOfWeek{
    SUNDAY, 
    MONDAY, 
    TUESDAY, 
    WEDNESDAY,
    THURSDAY, 
    FRIDAY,
    SATURDAY;

    public boolean isWeekDay(){
    return !isWeekEnd();   
    }

    public boolean isWeekEnd(){
    return (this == SUNDAY || this == SATURDAY); 
    }

}

public class Test{

    public static void main(String[] args) throws Exception{

    DaysOfWeek sun = DaysOfWeek.SUNDAY; 
    System.out.println("Is " + sun + " a weekend? " + sun.isWeekEnd());
    System.out.println("Is " + sun + " a week day? " + sun.isWeekDay());
    }
}

运行结果：

Is SUNDAY a weekend? true
Is SUNDAY a week day? false

 

第三部分：C#中有，Java中也有但完全不同的地方

 

1、嵌套类

 

在Java和C#中可以在一个类中嵌套另一个。在Java中有两种类型的嵌套类，非静态的嵌套类也就是内部类，以及静态的嵌套类。Java的内部类可以认为是内部类和其包含类一对一的关系，每一个包含类的实例都保存了一个相应内部类的实例，内部类可以额访问包含类的成员变量以及包含非静态的方法。Java的静态内部类可以访问包含类的静态成员和方法。C#也有Java的静态嵌套类，但是没有Java的内部类。如下嵌套类声明是等价的：

C# Code
public class Car{

  private Engine engine;

  private class Engine{

    string make; 

  }

}

Java Code
public class Car{

  private Engine engine;

  private static class Engine{

    String make; 

  }

}

注意：在Java中，嵌套类可以在任何代码块中声明，包括方法，在C#中则不能。在方法中创建嵌套类看上去不必要，但是结合匿名内部类可以提供强大的设计模式。

 

2、线程和易失成员

 

线程是程序内的顺序控制流程。程序或进程可以有多个线程并行执行，在执行任务的时候可以共享数据也可以独立运行。这样开发人员就可以在一个程序或进程中一次执行多个任务。线程的优点包括充分利用多处理器架构的资源、通过一边处理任务一边等待阻塞的系统调用（比如打印机或其它IO）减少执行时间，避免GUI应用程序失去响应。

 

Java线程可以通过继承java.lang.Thread并重写run()方法或者实现java.lang.Runable接口并实现run()方法来实现。在C#中，可以创建System.Threading.Thread对象并且传入System.Threading.Thread委托来表示需要线程运行的方法。在Java中，每一个类都从java.lang.Object继承wait()、notify()以及notify()。在C#中的等价是Thread.Threading.Montir类的Wait()、Pulse()以及PulseAll()。

 

using System;
using System.Threading;
using System.Collections;

public class WorkerThread
{

    private int idNumber;
    private static int num_threads_made = 1;
    private ThreadSample owner;

    public WorkerThread(ThreadSample owner)
    {

        idNumber = num_threads_made;
        num_threads_made++;
        this.owner = owner;

    }/* WorkerThread() */

    //sleeps for a random amount of time to simulate working on a task

    public void PerformTask()
    {

        Random r = new Random((int)DateTime.Now.Ticks);
        int timeout = (int)r.Next() % 1000;

        if (timeout < 0)
            timeout *= -1;

        //Console.WriteLine(idNumber + ":A");

        try
        {
            Thread.Sleep(timeout);
        }
        catch (ThreadInterruptedException e)
        {
            Console.WriteLine("Thread #" + idNumber + " interrupted");
        }

        //Console.WriteLine(idNumber + ":B");

        owner.workCompleted(this);

    }/* performTask() */


    public int getIDNumber() { return idNumber; }


} // WorkerThread

public class ThreadSample
{

    private static Mutex m = new Mutex();
    private ArrayList threadOrderList = new ArrayList();

    private int NextInLine()
    {

        return (int)threadOrderList[0];
    }

    private void RemoveNextInLine()
    {

        threadOrderList.RemoveAt(0);

        //all threads have shown up 
        if (threadOrderList.Count == 0)
            Environment.Exit(0);
    }


    public void workCompleted(WorkerThread worker)
    {

        try
        {

            lock (this)
            {


                while (worker.getIDNumber() != NextInLine())
                {

                    try
                    {
                        //wait for some other thread to finish working
                        Console.WriteLine("Thread #" + worker.getIDNumber() + " is waiting for Thread #" +
                                   NextInLine() + " to show up.");

                        Monitor.Wait(this, Timeout.Infinite);

                    }
                    catch (ThreadInterruptedException e) { }

                }//while


                Console.WriteLine("Thread #" + worker.getIDNumber() + " is home free");

                //remove this ID number from the list of threads yet to be seen
                RemoveNextInLine();

                //tell the other threads to resume
                Monitor.PulseAll(this);

            }

        }
        catch (SynchronizationLockException) { Console.WriteLine("SynchronizationLockException occurred"); }

    }

    public static void Main(String[] args)
    {


        ThreadSample ts = new ThreadSample();

        /* Launch 25 threads */
        for (int i = 1; i <= 25; i++)
        {
            WorkerThread wt = new WorkerThread(ts);
            ts.threadOrderList.Add(i);
            Thread t = new Thread(new ThreadStart(wt.PerformTask));
            t.Start();
        }

        Thread.Sleep(3600000); //wait for it all to end

    }/* main(String[]) */
}
Java Code
import java.util.*; 


class WorkerThread extends Thread{
       
    private Integer idNumber;
    private static int num_threads_made = 1; 
    private ThreadSample owner; 

    public WorkerThread(ThreadSample owner){
        
        super("Thread #" + num_threads_made);   
    
        idNumber = new Integer(num_threads_made);   
    num_threads_made++;        
    this.owner = owner;
    
    start(); //calls run and starts the thread.
    }/* WorkerThread() */
    
    //sleeps for a random amount of time to simulate working on a task
    public void run(){

    Random r = new Random(System.currentTimeMillis()); 
    int timeout = r.nextInt()  % 1000; 

    if(timeout < 0)
        timeout *= -1 ;

    try{        
        Thread.sleep(timeout);      
        } catch (InterruptedException e){
            System.out.println("Thread #" + idNumber + " interrupted");
        }
    
    owner.workCompleted(this); 

    }/* run() */
    
           
    public Integer getIDNumber() {return idNumber;}
         
    
} // WorkerThread

public class ThreadSample{

    private Vector threadOrderList = new Vector(); 
    
    private Integer nextInLine(){

    return (Integer) threadOrderList.firstElement(); 
    }

    private void removeNextInLine(){

    threadOrderList.removeElementAt(0);

    //all threads have shown up 
    if(threadOrderList.isEmpty())
        System.exit(0); 
    }

    public synchronized void workCompleted(WorkerThread worker){

    
    while(worker.getIDNumber().equals(nextInLine())==false){
    
        try {
        //wait for some other thread to finish working
        System.out.println (Thread.currentThread().getName() + " is waiting for Thread #" + 
                    nextInLine() + " to show up.");
        wait();
        } catch (InterruptedException e) {}
           
    }//while
    
    System.out.println("Thread #" + worker.getIDNumber() + " is home free");

    //remove this ID number from the list of threads yet to be seen
    removeNextInLine(); 

    //tell the other threads to resume
    notifyAll(); 
    }

    public static void main(String[] args) throws InterruptedException{
    

    ThreadSample ts = new ThreadSample(); 

    /* Launch 25 threads */ 
    for(int i=1; i <= 25; i++){
        new WorkerThread(ts); 
        ts.threadOrderList.add(new Integer(i)); 
    }

    Thread.sleep(3600000); //wait for it all to end
    
    }/* main(String[]) */ 


}//ThreadSample

 

在许多情况下，我们不能确保代码执行的顺序和源代码一致。产生这种情况的原因包括编译器优化的时候重排语句顺序、或多处理器系统不能在全局内存中保存变量。要避免这个问题，C#和Javay引入了volatile关键字来告诉语言运行时不要重新调整字段的指令顺序。

 

C# Code

/* Used to lazily instantiate a singleton class */ 
/*             WORKS AS EXPECTED                */
  class Foo {
        private volatile Helper helper = null;
        public Helper getHelper() {
            if (helper == null) {
                lock(this) {
                    if (helper == null)
                        helper = new Helper();
                }
            }
            return helper;
        }
    }


Java Code

/* Used to lazily instantiate a singleton class */ 
/* BROKEN UNDER CURRENT SEMANTICS FOR VOLATILE */ 

  class Foo {
        private volatile Helper helper = null;
        public Helper getHelper() {
            if (helper == null) {
                synchronized(this) {
                    if (helper == null)
                        helper = new Helper();
                }
            }
            return helper;
        }
    }

尽管上面的代码除了lock和synchronized关键字之外没什么不同，Java的版本不保证在所有的JVM下都工作，详见http://www.javaworld.com/javaworld/jw-02-2001/jw-0209-double.html。在C#中volatile的语义不会出现这样的问题，因为读写次序不能调整，同样被标记volatile的字段不会保存在寄存器中，对于多处理器系统确保变量保存在全局内存中。

 

3、操作符重载

 

操作符重载允许特定的类或类型对于标准操作符具有新的语义。操作符重载可以用于简化某个常用操作的语法，比如Java中的字符串连接。操作符重载也是开发人员争议的一个地方，它在带来灵活性的同时也带来了滥用的危险。有些开发者会乱用重载（比如用++或--来表示连接或断开网络）或是让操作符不具有本来的意义（比如[]返回一个集合中某个索引项的复制而不是原始的对象）或重载了一半操作符（比如重载<但是不重载>）。

注意，和C++不用，C#不允许重载如下的操作符：new、()、||、&&、=或各种组合赋值，比如+=、-=。但是，重载的组合赋值会调用重载的操作符，比如+=会调用重载的+。

 

C# Code
using System;

class OverloadedNumber{

    private int value; 

    public OverloadedNumber(int value){

    this.value = value; 

    }

    public override string ToString(){
    return value.ToString(); 
    }


    public static OverloadedNumber operator -(OverloadedNumber number){
    return new OverloadedNumber(-number.value); 
    }

    public static OverloadedNumber operator +(OverloadedNumber number1, OverloadedNumber number2){
    return new OverloadedNumber(number1.value + number2.value); 
    }

    public static OverloadedNumber operator ++(OverloadedNumber number){
    return new OverloadedNumber(number.value + 1); 
    }

}

public class OperatorOverloadingTest {

  
    public static void Main(string[] args){

    OverloadedNumber number1 = new OverloadedNumber(12); 
    OverloadedNumber number2 = new OverloadedNumber(125); 

    Console.WriteLine("Increment: {0}", ++number1);
    Console.WriteLine("Addition: {0}", number1 + number2);
  
    }
} // OperatorOverloadingTest

image

 

4、switch语句

 

C#的switch和Java的switch有两个主要的区别。在C#中，switch语句支持字符串常量，除非标签不包含任何语句否则不允许贯穿。贯穿是显式禁止的，因为可能导致难以找到的bug。

C# Code

switch(foo){    
    
    case "A": 
        Console.WriteLine("A seen");
        break;
    case "B": 
    case "C": 
        Console.WriteLine("B or C seen");
        break; 

        /* ERROR: Won't compile due to fall-through at case "D" */
    case "D": 
        Console.WriteLine("D seen");
    case "E":
        Console.WriteLine("E seen");
        break; 
    }

image

 

5、程序集

 

C#程序集和Java的JAR文件有很多共性。程序集是.NET环境最基本的代码打包单元。程序集包含了中间语言代码、类的元数据以及其它执行任务所需要的数据。由于程序集是最基本的打包单元，和类型相关的一些行为必须在程序集级别进行。例如，安全授权、代码部署、程序集级别的版本控制。Java JAR文件有着相似的作用，但是实现不一样。程序集一般是EXE或DLL而JAR文件是ZIP文件格式的。

作者: lovecindywang 发表于 2012-02-09 17:57 原文链接

评论: 5　查看评论　发表评论

最新新闻：
· 苹果征集iPad 3发布会演示应用 重点是图形应用(2012-02-10 17:23)
· 京东商城涉足汽车销售 将上线售车频道(2012-02-10 17:21)
· 亚马逊新广告挑衅苹果：一个iPad可买三台kindle(2012-02-10 17:20)
· 动视暴雪确认今年第二季度推出《暗黑破坏神3》(2012-02-10 16:59)
· 官方承认 Google Bar 逆行倒施(2012-02-10 16:55)

编辑推荐：高级编程语言的发展历程

网站导航：博客园首页  我的园子  新闻  闪存  博问  知识库

]]>Spread WPF-Silverlight CTP 探秘http://www.cnblogs.com/powertoolsteam/archive/2012/02/09/2343927.html葡萄城控件技术团队博客葡萄城控件技术团队博客Thu, 09 Feb 2012 06:34:00 GMThttp://www.cnblogs.com/powertoolsteam/archive/2012/02/09/2343927.html

Spread WPF-Silverlight -- 将Excel功能嵌入到你的Silverlight 应用中。

Spread WPF-Silverlight 是一款嵌入式表格控件产品，用于快速建立WPF和Silverlight平台上高级应用程序，包括商业、工程和科学等应用。通过Spread可以将Excel文档导入到应用程序中，并执行商业或者统计规则同时控制整体的用户体验。也可以将数据和分析结果保存成Excel、xml或者其他格式的文档，便于提交和分享。此外，Spread全新支持模板功能，通过设计器制作并可共享使用。

 

下面就开始探秘啦：

  • Excel 导入导出。支持.xls和 .xlsx。
  • 将外部数据源读入Spread。
  • 功能丰富的Spread设计器。

image

 

波形图（Sparklines）

波形图是直接画在单元格里的微型图表，用于可视化的呈现数据。Spread 支持列、线和正负类型的波形图，同时可以与Excel 2010文件兼容及转换。

image

 

 

Cell Border:

13种线型，颜色设定，四边不同线型，GridLine定制，与Excel完全相同。

image

 

Cell Style: 控制了单元格，就控制了交互！

丰富的单元格风格设定,包括字体，色彩，边框，对齐，缩进，折行，文字格式，验证方式，公式计算，编辑控制，主题设定等。还有灵活强大的风格行列继承功能。

image

 

Conditional Format:让单元格原地满状态复活！

根据不同的条件单元格显示不同的风格。基于强大的公式，灵活设定各种条件。丰富的风格设定，包括多组内置图标以及颜色柱状背景的显示。让数据显示更加生动活泼，重点突出。

image

 

Drag Fill: 快速填充-数据编辑的必杀利器！

 

一定在Excel中见过用过的了，一个快速填充数据的利器。

image

 

Range Filter: 区域数据分析助BI一臂之力！

对一个范围内的数据进行过滤排序，辅助数据分析。通过代码还可以对各种类型的数进行更加各种条件的过滤功能。

image

 

 

Freeze: 超越Excel的冻结功能！

固定行头列头不滚动，在用Excel制作表格的时候可是经常使用的。可让行脚列脚也固定不能滚动，那可就需要用Spread WPF-Silverlight啦。

image

 

Range Group: 是行是列，拉出来分组！

对数据进行行的分组是一般Grid都有的功能,而对于列的分组就是SpreadSheet的特色了。

image

 

Cell Merge: 不会Merge的单元格不是好控件。

制作表格的时候，是少不了单元格合并的。当然，这个图不是来自Excel。

image

 

更多技术细节请关注新浪微博@葡萄城控件!

 

Spread Silverlight Demo Site

Spread WPF-Silverlight CTP 下载

作者: 葡萄城控件技术团队博客 发表于 2012-02-09 14:34 原文链接

评论: 5　查看评论　发表评论

最新新闻：
· 苹果征集iPad 3发布会演示应用 重点是图形应用(2012-02-10 17:23)
· 京东商城涉足汽车销售 将上线售车频道(2012-02-10 17:21)
· 亚马逊新广告挑衅苹果：一个iPad可买三台kindle(2012-02-10 17:20)
· 动视暴雪确认今年第二季度推出《暗黑破坏神3》(2012-02-10 16:59)
· 官方承认 Google Bar 逆行倒施(2012-02-10 16:55)

编辑推荐：高级编程语言的发展历程

网站导航：博客园首页  我的园子  新闻  闪存  博问  知识库

]]>Database2Sharp版本更新之自定义模板生成http://www.cnblogs.com/wuhuacong/archive/2012/02/09/2341927.html伍华聪伍华聪Thu, 09 Feb 2012 01:57:00 GMThttp://www.cnblogs.com/wuhuacong/archive/2012/02/09/2341927.html
代码生成工具一直是很多从事开发人员的必备，一般开发人员都会选择一款高效、适合自己开发模式的代码生成工具，我也不例外，我一直让我的Database2Sharp(http://www.iqidi.com/database2sharp.htm)代码生成工具围绕我的开发框架来生成代码，至今已经经过快7个年头的洗礼，主要是提供高效、快速的一键生成整个项目框架源码的操作。

代码生成工具Database2Sharp自一开始，就采用基于模板方式的代码生成方式，这样提高生成效率，并且减少维护成本（相对某些硬编码代码生成的方式更优），方便用户对模板进行适当的修改等特点，不过虽然是提供了模板修改的功能，但是由于在工具的主界面上，并未提供对自定义模板文件的管理，因此以前的版本一直没有完成用户自定义模板管理维护的功能，本次版本更新就是弥补这一不足，发挥模板应有的魅力和功能。

在实际开发当中，自定义模板生成是很多代码生成工具生成代码的重要补充，例如有些项目代码片段需要（例如控件赋值语句，或者控件数据显示语句等），如果能通过自定义模板方式，利用模板引擎的灵活特点，以及已有数据库的结构信息，就很方便生成重复性强、有一定规律的代码。

因此，本次Database2Sharp版本更新，主要就是提供一个对自定义模板管理，方便利用自定义模板灵活、高效的特点，并且利用后台数据库表、字段等信息，为实际的项目代码片段生成服务，本次还调整了整体的软件界面布局，利用成熟的Weifenluo布局控件，更好展示多文档的信息。 


 

 

 我们来看看自定义代码生成模块的功能是如何实现的，首先提供一个自定义模板列表进行维护，可以通过右键菜单进行添加、修改、重命名、删除等操作，模板代码可以进行【直接执行模板】和【选表进行代码生成】两种方式。

 

 利用【选表进行代码生成】方式，可以很好利用后台的数据库表、字段等信息，结合模板生成高效的代码，如下所示。

 


另外，为了方便大家对模板引擎NVelocity的了解，在软件工具安装的时候，附带了几个常见的例子，如下所示。

 

 

 例子的代码大致如下所示，主要是让大家快速了解Nvelocity的模板语言VTL的使用。如果对模板引擎更加深入的了解，可以查看我之前的随笔《强大的模板引擎开源软件NVelocity》进一步了解。

遍历及注释，赋值语句例子。 

##Foreach语法操作函数

#set( $criteria = ["name", "address"] )
#foreach( $criterion in $criteria )
    $criterion
#end


##注释操作

注释
单行注释
## This is a single line comment

多行注释 
#*
 Thus begins a multi-line comment. Online visitors won't
 see this text because the Velocity Templating Engine will
 ignore it.
*# 


条件结构的例子 

##此处为注释说明
##简单例子(主要规则：引用以$开头用于取得什么东西，而指令以# 开始用于做什么事情)
##在VTL中，所有变量标识符的开头要加上$字符，如$Name，也可以用一种更加明确的方法表示，例如${name}。

#set($foo = false)
#if ($foo)
    this is true
#elseif ($bar)
    this is false
#elseif (true)
    this should be followed by two blank lines
#end

## this is a single line comment

#*
this is a multi line comment
#if (
*#


#set($user = "jason")
#set($login = false)
#set($count = 5)

#if ($user == "jason")
    the user $user is logged in!
#end

#if ($count == 5)
    the count is 5!
#end

#if ($login == false)
    the user isn't logged in.
#end

#if ($count != 3)
    \$count is not equal to 3

#end  


宏脚本例子 

## #macro 脚本元素允许模板设计者在VTL 模板中定义重复的段。 
## Velocimacros 不管是在复杂还是简单的场合都非常有用。
## 下面这个Velocimacro，仅用来节省击键和减少排版错误，介绍了一些NVelocity宏的概念。 
## 可以带参数，参数放在宏名称的后面，空格隔开

#macro( d )
<tr><td></td></tr>
#end
 

#d()


 以及一些常用的赋值及数据显示代码片段

        /// <summary>
        /// 初始化
        /// </summary>
        /// <param name="info">实体类信息</param>
        private void InitData(${ClassName}Info info)
        {
#foreach($ColumnInfo in ${TableInfo.ColumnList.Values})        
#if(${ColumnInfo.AutoIncrement} == false)    
#if(${ColumnInfo.NetType} == "System.String" )
            this.txt${ColumnInfo.Name.Alias.ToCapit()}.Text = info.${ColumnInfo.Name.Alias.ToCapit()};
#elseif(${ColumnInfo.NetType} == "System.DateTime")
            this.txt${ColumnInfo.Name.Alias.ToCapit()}.Text = info.${ColumnInfo.Name.Alias.ToCapit()}.ToShortDateString();
#else
            this.txt${ColumnInfo.Name.Alias.ToCapit()}.Text = info.${ColumnInfo.Name.Alias.ToCapit()}.ToString();
#end
#end ##endif
#end
        }        
                
        /// <summary>
        /// 获取数据
        /// </summary> 
        private ${ClassName}Info GetData()
        { 
            ${ClassName}Info info = new ${ClassName}Info();
#foreach($ColumnInfo in ${TableInfo.ColumnList.Values})        
#if(${ColumnInfo.AutoIncrement} == false)     
#if(${ColumnInfo.NetType} == "System.Decimal" )
            info.${ColumnInfo.Name.Alias.ToCapit()} = Helper.SafeConvertDecimal(this.txt${ColumnInfo.Name.Alias.ToCapit()}.Text);
#elseif(${ColumnInfo.NetType} == "System.DateTime")    
            info.${ColumnInfo.Name.Alias.ToCapit()} = Helper.SafeConvertDate(this.txt${ColumnInfo.Name.Alias.ToCapit()}.Text);        
#else
            info.${ColumnInfo.Name.Alias.ToCapit()} = this.txt${ColumnInfo.Name.Alias.ToCapit()}.Text;   
#end          
#end ##endif
#end

         }  


 当然，了解这些可能还不够，还需要了解模板后台，能够利用的数据属性等信息，包括数据库、表、字段等相关的属性，方便在模板引擎中进行调用，生成更加强大的代码片段。

软件安装后，有一个帮助文件，是提供给开发者进行了解模板后台数据的相关属性和方法的，如下所示。

 

 运行后如下所示：

 

 

 除了以上新增的功能外，一键生成基于我的Winform框架结构的项目代码，是最为重要的功能，可以体验一下。另外，代码生成工具生成的数据库文档，快速生成实体类信息等模块，也是开发非常常用的功能，如果想了解更加关于我的代码生成工具的信息，可以参考我博客里面的标签【代码生成工具】。

 

作者: 伍华聪 发表于 2012-02-09 09:57 原文链接

评论: 4　查看评论　发表评论

最新新闻：
· 苹果征集iPad 3发布会演示应用 重点是图形应用(2012-02-10 17:23)
· 京东商城涉足汽车销售 将上线售车频道(2012-02-10 17:21)
· 亚马逊新广告挑衅苹果：一个iPad可买三台kindle(2012-02-10 17:20)
· 动视暴雪确认今年第二季度推出《暗黑破坏神3》(2012-02-10 16:59)
· 官方承认 Google Bar 逆行倒施(2012-02-10 16:55)

编辑推荐：高级编程语言的发展历程

网站导航：博客园首页  我的园子  新闻  闪存  博问  知识库

]]>大叔手记（19）：你真懂JavaScript吗？http://www.cnblogs.com/TomXu/archive/2012/02/09/2330578.html汤姆大叔汤姆大叔Thu, 09 Feb 2012 01:45:00 GMThttp://www.cnblogs.com/TomXu/archive/2012/02/09/2330578.html

介绍

大叔整理的《深入理解JavaScript系列》已经快20篇了，不知道大家看的如何了？ 除了大家熟知的闭包、原型、作用域以外，不知道大家是否真正理解了JavaScript的核心特性，在网上发现几个小题目非常有意思，正好适合考察大家对JavaScript的理解。

如果大家有兴趣（或者自认为对JavaScript了解还不错的人），可以尝试着回答一下下面5个题目的输出结果（不要google或baidu哦）。

至于正确结果嘛，自己可以将代码复制到浏览器里就可以看到了（稍后这两天，我会将详细的解释单独发帖整理出来）。

PS：大胆点，不管结果对不对，都把你的答案贴出来（最好带有自己的想法，后面我们和准确解释做对比，这也是学习的过程）。

答案已经贴在《深入理解JavaScript系列（20）：《你真懂JavaScript吗？》答案详解》里了

正文

题目1：

if (!("a" in window)) {
    var a = 1;
}
alert(a);

 

题目2

var a = 1,
    b = function a(x) {
        x && a(--x);
    };
alert(a);

 

题目3：

function a(x) {
    return x * 2;
}
var a;
alert(a);

 

题目4：

function b(x, y, a) {
    arguments[2] = 10;
    alert(a);
}
b(1, 2, 3);

 

题目5：

function a() {
    alert(this);
}
a.call(null);

同步与推荐

本文已同步至目录索引：《大叔手记全集》

大叔手记：旨在记录日常工作中的各种小技巧与资料（包括但不限于技术），如对你有用，请推荐一把，给大叔写作的动力。

作者: 汤姆大叔 发表于 2012-02-09 09:45 原文链接

评论: 62　查看评论　发表评论

最新新闻：
· 苹果征集iPad 3发布会演示应用 重点是图形应用(2012-02-10 17:23)
· 京东商城涉足汽车销售 将上线售车频道(2012-02-10 17:21)
· 亚马逊新广告挑衅苹果：一个iPad可买三台kindle(2012-02-10 17:20)
· 动视暴雪确认今年第二季度推出《暗黑破坏神3》(2012-02-10 16:59)
· 官方承认 Google Bar 逆行倒施(2012-02-10 16:55)

编辑推荐：高级编程语言的发展历程

网站导航：博客园首页  我的园子  新闻  闪存  博问  知识库

]]>