这些资料是我学习的时候在网络上寻找到的,发布出来希望对大家有帮助,一起努力前进,嘿嘿......Microsoft C#规范 2.0 版 GFC用户提交

feedsky 抓虾 pageflakes google reader my yahoo bloglines 鲜果 有道 http://wap.feedsky.com/bliplink
显示标签为“c#语法知识”的博文。显示所有博文
显示标签为“c#语法知识”的博文。显示所有博文

Array

using System;

namespace MyArray
{
 //System.Object--->System.Array-->类型[]   由 CLR自动创建 类型[]

 //为了符合CLS的要求,所有数组都必须是0基数组(即最小索引为0)

 //如有可能,应该坚持使用一维0基数组,因为可以使用特殊的IL指令(newarr,ldelem,ldelema,ldlen和stelem)来处理它们,
 //而且这些特殊的IL指令会导致JIT编译器生成优化的代码,性能是最佳的。

 //访问数组元素需要利用索引(index)。
 //数组元素的类型叫做数组的类型。

 //值类型数组(自动清0)、引用类型数组(自动清null)。

 //C#中的数组存在越界检查,同时类型的溢出也会被检查。但在编译时间不检查,而是在运行时检查。

 //new: 
 //      除了数组元素,数组对象所占有的内存块还包含一个类型指针、一个同步索引块,
 //      保存在该数据的内存快的开销部分(overhead);
 //  一些额外的参数信息(数组的元素类型、数组的维数、数组每一维的最低下限<默认为0>和每一维的长度),
 //      保存在该数据的内存块的开销部分(overhead);
 //  返回数组的内存块地址。

 //不规则数组是由数组构成的数组。规则数组的空间是连续的,不规则数组的空间是不连续的。

 //返回数组参数的方法:如果该数组中不含有任何元素,Microsoft强烈建议您让它返回一个零长度的数组,
 //而不是返回一个空引用null,因为这样做能简化开发人员在调用该方法时需要编写的代码
 //同样如果类中的成员变量是一个数组引用,就应该让该成员始终引用数组,即使数组中不含有任何元素。

 class MyArray
 {
  /// <summary>
  /// 应用程序的主入口点。
  /// </summary>
  [STAThread]
  static void Main(string[] args)
  {
   //引用类型数组的类型转换
   //指向同一引用数组
   //数组类型变量的类型如果是数组元素类型的同类或者是基类,就可以进行隐式或显示转换
   string[] sa = new string[100];
   object[] oa = sa;
   oa[0] = "student";
   oa[1] = 5;//编译通过,因为等号右面的类型是左面的类型的同类或者是派生类
             //运行出错,因为运行时(CLR)检查到数组元素的类型为string类型,而实例的类型为int类型。


   // 所有数组都隐式继承自System.Array
   string[] sArray;
   //由 CLR自动创建一个string[]类型,将隐式继承自System.Array,而不时有C#生成IL代码
  
   Array a;
   a = new String[3];
//   a[0]  = "student";

  }
 }
}


......

[阅读全文]

AttributeUsageAttribute

using System;
using System.Reflection;

//第一步:定义属性类。

//AttributeUsage属性向编译器指出自定义属性的合法应用范围。
//所有编译器都内建对这个属性的支持,并会在用户自定义属性应用于一个无效目标的时候报告错误。

//定义您自己的特性类时,可通过在特性类上放置 AttributeUsageAttribute 来控制特性类的使用方式。指示的特性类必须直接或间接地从 Attribute 派生。
//
//特性类具有定位参数和命名参数。特性类的每个公共构造函数为该类定义一个有效的定位参数序列。命名参数则由特性类的非静态、公共和读写字段或属性定义。
//
//通过定义以下参数设置 AttributeUsageAttribute 的三个属性:
//
//ValidOn
//该定位参数指定可在其上放置所指示的特性的程序元素。AttributeTargets 枚举数中列出了可在其上放置特性的所有可能元素的集合。
//可通过按位“或”运算组合多个 AttributeTargets 值,以获取所需的有效程序元素组合。默认值为 All。
//
//AllowMultiple
//该命名参数指定能否为给定的程序元素多次指定所指示的特性,
//如果允许指定多个实例,则为 true;否则为 false。默认值为 false,属性就只能向一个选定的属性目标应用一次。
//
//Inherited
//该命名参数指定所指示的属性能否由派生类和重写成员继承。
//如果该属性可由派生类和重写成员继承,则为 true,否则为 false。默认值为 true。
//可继承属性不会造成在托管模块中为派生类型生成额外的元数据。

//定义自己的属性类时,未应用一个AttributeUsageAttribute属性,编译器和CLR会认为该属性能应用与所有目标,
//向每个目标都只能应用一次,而且是可继承的。
//这些假定模拟了AttributeUsageAttribute类中的默任字段值

 


//AttributeUsage属性类的FCL源代码:

[Serializable]
[AttributeUsageAttribute(AttributeTargets.Class,Inherited = true)]
public sealed class AttributeUsageAttribute : Attribute
{
 internal static AttributeUsageAttribute Default = new AttributeUsageAttribute(AttributeTargets.All);

 internal Boolean m_allowMultiple = false;
 internal AttributeTargets m_attributeTarget = AttributeTargets.All;
 internal Boolean m_inherited = true;

 public AttributeUsageAttribute(AttributeTargets validOn)
 {
  m_attributeTarget = validOn;
 }

 public Boolean AllowMultiple
 {
  get
  {
   return m_allowMultiple;
  }
  set
  {
   m_allowMultiple = value;
  }
 }

 public Boolean Inherited
 {
  get
  {
   return m_inherited;
  }
  set
  {
   m_inherited = value;
  }
 }

 public AttributeTargets ValidOn
 {
  get
  {
   return m_attributeTarget;
  }
 }
}

 

//[Flags]
//[Serializable]
//public enum AttributeTargets
//{
//}

 

//定义属性类的实例构造器、字段和properties 时,合法的数据类型集合限制为:
//Boolean,Char,Byte,Sbyte,Int16,UInt16,Int32,UInt32,Int64,UInt64,Single,Double,String,Type,Object
//或一个枚举类型,还可以使用一个基于零的一维数组。

//[Flags]
[Serializable]
public class MyAttribute
{
 private string name;
 MyAttribute(String name)
 {
  name = name;
 }
}


 


......

[阅读全文]

Event_add_remove

#define NonRobustThreadSafety
using System;

//触发事件的来源:
//1.用户的操作
//2.系统的状态变化
//3.程序调用

//事件的发送者:触发事件的对象(含有调用事件委托的对象)
//事件的接受者:接受事件的对象(含有事件方法<订阅事件委托的方法>的对象)

//公共语言运行库(CLR)的事件模型建立在委托机制之上。

namespace Event
{
 //对外提供事件成员的事件类
 internal class MailManager
 {
  //第1步:定义一个事件参数类型,按照约定,该类型从System.EventArgs类派生,并且该类的名称应按以EventArgs结尾,
  //   用于存放所有需要发送给事件通知的接受者的附加信息。

  //如果事件不生成数据,则使用事件数据对象的基类 EventArgs,EventArgs 是包含事件数据的类的基类。
  //此类不包含事件数据,在事件引发时不向事件处理程序传递状态信息的事件会使用此类,
  //可以直接使用EventArgs.Empty,不需要构建一个新的System.EventArgs派生类。
  //如果事件处理程序需要状态信息,则应用程序必须从此类派生一个类来保存数据。
  //[Serializable]
  //public class EventArgs
  //{
  // public static readonly EventArgs Empty = new EventArgs()
  // public EventArgs();
  //}

  internal class NewMailEventArgs : EventArgs
  {

   private readonly String m_from, m_to, m_subject;

   public NewMailEventArgs(String from, String to, String subject)
   {
    m_from = from; m_to = to; m_subject = subject;
   }
  
   public String From    { get { return m_from;    } }
   public String To      { get { return m_to;      } }
   public String Subject { get { return m_subject; } }
  }

  //第2步:定义事件委托类型

  // 如果事件不生成数据,则使用事件委托的预定义 EventHandler,表示将处理不包含事件数据的事件的方法。
  //[Serializable]
  //public delegate void EventHandler
  //(
  // object sender,
  // EventArgs e
  //);

  //事件模式要求sender参数的类型为Object
  //事件模式要求委托定义和回调方法将派生自EventArgs的参数命名为e,仅为增加事件模式一致性
  //事件模式要求所有的事件处理程序的返回类型都为void

  public delegate void  NewMailEventHandler(object sender,NewMailEventArgs e);

  //增加一个引用委托链表头部的私有委托字段。
  private NewMailEventHandler m_NewMail;

  // 第3步:定义事件成员(显式实现)
  //每个方法都接受一个称为value的隐藏参数,该参数类型为NewMailEventHandler
  //事件必须同时拥有add和remove访问器方法
  public event NewMailEventHandler NewMail
  {
   //显式实现add方法
   add
   {
    m_NewMail += new NewMailEventHandler(value);
   }
   //显式实现remove方法
   remove
   {
    m_NewMail -= new NewMailEventHandler(value);
   }
  }

  //C#编译器将这行代码编译成下面内容:但不能显示地调用add和remove方法。
  //1.一个被初始化为null的总是私有<Private>的委托类型的字段
  // private NewMailEventHandler NewMail = null;
  //2.一个允许对象订阅事件的公共方法add_XXX(其中XXX是事件的名称)---add访问器
  // public void add_NewMail(NewMailEventHandler value)
  // {
  //  NewMail = (NewMailEventHandler)Delegate.Combine(NewMail,value);
  // }
  //3.一个允许对象注销事件的公共方法remove_XXX(其中XXX是事件的名称)remove访问器
  // public void remove_NewMail(NewMailEventHandler value)
  // {
  //  NewMail = (NewMailEventHandler)Delegate.Remove(NewMail,value);
  // }
  //4.在元数据中生成一个事件定义的条目

  // 第4步:定义触发事件的方法,来通知已订阅事件的对象事件已发生。
  //  按照约定该方法是类的一个受保护的虚方法,该类及其派生类中的代码可以调用这个虚方法,
  //  该方法的默认实现仅仅检查是否有对象已经订阅了事件
  protected virtual void OnNewMail(NewMailEventArgs e)
  {

   NewMailEventHandler temp = m_NewMail;

   //处于线程安全的考虑,将委托字段保存到一个临时的字段中
   if (temp != null) temp(this, e);
  }

  // 第5步:接收触发事件信息的方法
  //  在定义的类中,必须还有一些方法可以将外部的输入转换为引发事件的动作。
  public void SimulateNewMail(String from, String to, String subject)
  {
   //创建事件参数
   NewMailEventArgs e = new NewMailEventArgs(from, to, subject);

   //调用触发事件的虚方法
   OnNewMail(e);
  }
 }

 //包含事件处理方法的类
 internal sealed class Fax
 {
  //实现事件订阅或者注销的代码不能判断事件的add和remove访问器方法是由
  //编译器自动创建的还是由编程人员显式实现的。
  //订阅或者注销事件的代码仍然可以使用+=和-=操作符,
  //而且编译器在遇到这两个操作符时会自动生成显式方法的调用。

  public Fax(MailManager mm)
  {

   mm.NewMail +=  new MailManager.NewMailEventHandler(FaxMsg);
   //C#编译器对事件提供了内置的支持,将该行代码翻译成下述代码,生成对事件add_NewMail方法的调用:
   //mm.add_NewMail(new MailManager.NewMailEventHandler(this.FaxMsg))
  }

  private void FaxMsg(Object sender, MailManager.NewMailEventArgs e)
  {
            Console.WriteLine("Faxing mail message:");
   Console.WriteLine("   From={0}, To={1}, Subject={2}",
    e.From, e.To, e.Subject);
  }

  public void Unregister(MailManager mm)
  {

   mm.NewMail -=  new MailManager.NewMailEventHandler(FaxMsg);
   //C#编译器对事件提供了内置的支持,将该行代码翻译成下述代码,生成对事件remove_NewMail方法的调用:
   //mm.remove_NewMail(new MailManager.NewMailEventHandler(this.FaxMsg))
  }
 }

 //包含事件处理方法的类
 internal sealed class Pager
 {
  public Pager(MailManager mm)
  {
   mm.NewMail +=  new MailManager.NewMailEventHandler(SendMsgToPager);
  }

  private void SendMsgToPager(Object sender, MailManager.NewMailEventArgs e)
  {
   Console.WriteLine("Sending mail message to pager:");
   Console.WriteLine("   From={0}, To={1}, Subject={2}",
    e.From, e.To, e.Subject);
  }

  public void Unregister(MailManager mm)
  {
   mm.NewMail -= new MailManager.NewMailEventHandler(SendMsgToPager);
  }
 }

 class Event
 {
  /// <summary>
  /// 应用程序的主入口点。
  /// </summary>
  [STAThread]
  public static void Main()
  {
   MailManager mm = new MailManager();

   Fax fax = new Fax(mm);

   Pager pager = new Pager(mm);

   mm.SimulateNewMail("Jeffrey", "Kristin", "I Love You!");

   fax.Unregister(mm);

   mm.SimulateNewMail("Jeffrey", "Mom & Dad", "Happy Birthday.");
  } 
 }
}


......

[阅读全文]

Exception

using System;

//正确使用异常处理,可以极大地减轻软件开发人员的负担;
//但是,如果使用不当,异常处理可能隐藏代码中的一些严重的问题,也有可能传递一些关于实际问题的错误信息。

//异常处理(exception handling)结构:用4个关键字try、catch、throw和finally使异常问题采用结构化的、统一的和类型安全的方式来进行处理,
//                                    可以编写出可维护性和健壮性更强的代码,
//                                    而且使程序代码更清晰、简洁增加了程序的可读性,
//                                    更重要的是规范了程序的设计风格,有利于提高程序的质量。
//                                    通过使用异常处理,在编写代码的时候,可以假定这些异常不会发生,只关心编写正确流程的代码。
//当发生某种异常时,CLR就会创建一个表示这个异常的对象,这个对象从具有问题的代码中抛出,异常可以在任何时候抛出。
//在C#中,所有的异常必须由System.Exceptionl类或由从System.Exceptionl类派生的类的异常实例来表示,

//异常:在程序运行期间代码未能完成它应执行的任务时,应抛出一个异常类的对象。
//异常产生的原因:    1)由应用程序本身抛出的异常类的对象,大多数情况下这种异常可以恢复。
//                    2)由公共语言运行时环境CLR抛出的异常类的对象,大多数情况下这种异常难以恢复。
//异常产生的方式:    1)由系统抛出自动检测到的异常类的对象。
// (抛出异常的方式) 2)由throw语句抛出人为产生的异常类的对象,
//                       应在异常对象中包含一个字符串消息,提供详细信息说明方法为何无法完成任务,并且如果可能,应阐释如何纠正错误。
//异常处理的三种结构:1)try-catch
//                    2)try-finally
//                    3)try-catch=finally
//异常处理的过程:产生异常---->捕捉异常---->消除异常---->继续执行程序

//异常产生的作用:1)通过catch块中的异常恢复代码,进行异常恢复。
//                2)通过未处理异常(当抛出的异常无法处理时,该异常的消息通常被写入到一个日志中,开发人员可以查看日志,使用消息中的信息来修复代码的bug),查找程序的bug。


public sealed class Program
{
 [STAThread]
 static void Main(string[] args)
 {
  //未处理异常:通常会被写入日志文件中。
  //如果没有catch块与被抛出的异常类型匹配,会出现未处理异常。
  //当CLR检测到进程中的任意线程有未处理异常,会终止进程。
  //未处理异常表明应用程序遇到了未预料的情况,而且还是应用程序的真正的bug。
  //类库开发人员不必考虑未处理异常,只有应用程序的开发人员需要考虑未处理异常。
  //应用程序应设置一种策略来处理未处理异常,这时应将bug报告给发行该应用程序的公司,修改bug,发行一个新版本的应用程序。

  //在分布式环境中,理想情况下应用程序发生未处理异常时应记录到日志中,
  //然后向客户端发送通知表明所请求的操作无法完成,接着终止服务器应用程序(但在非理想的的环境中不太切合实际,例如SQL Server)。
  //Microsoft实际上建议应用程序的开发人员只需接受CLR的默任策略。

  //修复未处理异常:
  //1.修改代码使catch语句捕捉一个更具体的异常。
  //2.重写代码消除导致异常抛出的条件。

  Program p = new Program();
  p.SomeMethod();
 }

 private void SomeMethod()
 {


  try
  {
   //在这个try块中放入以下要求的代码:
   //1)要求执行异常恢复操作:将可能产生异常的程序代码放入try块中。异常恢复代码应该放在一个或多个catch块中。
   //2)要求执行公共资源清理操作。资源清理代码应该放在一个单独的finally块中。
  }

  //CLR自上而下地搜索匹配的catch语句,所以安排catch语句异常处理顺序的一般原则是:
  //捕捉具体异常类的catch语句在前面,接着捕捉具体异常类的基类的catch语句在后面,最后是捕捉System.Exception异常类的catch语句。
  //1)如果异常被某个catch语句捕捉,则所有其它catch语句都会被忽略,异常从系统中删除。
  //2)如果所有catch语句均未捕捉到异常,则异常将被传播到调用try块的上一级(上一级try块或上一级方法)
  //3)在捕捉到异常的catch块中,在块的尾部可以有三种选择:
   //          a)重新抛出相同的异常,则异常将被传播到调用try块的上一级(上一级try块或上一级方法)
   //          b)抛出一个不同的异常,则异常将被传播到调用try块的上一级(上一级try块或上一级方法)
   //          a)让线程从catch块的底部退出

  //应该为应用程序可以从中恢复的每一种异常都创建一个catch块。catch块中通常包含的是恢复某类异常时需要执行的操作规程代码。
  //带参数的catch语句捕捉异常:当抛出的异常对象的类型是catch语句参数类型的同类或派生类时,异常被捕捉。
  //                           catch语句中的异常变量将引用抛出的异常对象,应该把它当成只读变量,尽量不要修改该对象。
  //参数的类型称为捕捉类型,在C#中必须将捕捉类型指定为System.Exceptionl异常类或者派生自从System.Exceptionl类的异常类。

  catch (InvalidCastException e)
  {
   //把处理try块中可能产生的异常的代码放到catch块中
   //此catch块的代码将处理异常并消除异常,或重新抛出异常

   //在这个catch块中放入那些能够从InvalidCastException类型的异常
   //(或者任何派生自InvalidCastException的异常类型)中恢复的代码。
  }
  catch (NullReferenceException)
  {
   //在这个catch块中放入那些能够从NullReferenceException类型的异常
   //(或者任何派生自NullReferenceException的异常类型)中恢复的代码。
  }
  //带Exception参数的catch语句将捕捉所有类型的异常
  catch (Exception)
  {
   //在这个catch块中放入那些能够从任何类型的异常中恢复的代码。
   //捕捉到的任何一个异常时,都应该将其重新抛出,否则、异常处理可能隐藏代码中的一些严重的问题。
   //如果捕捉了这个异常,然后又忽略它并继续执行应用程序,应用程序可能产生无法预料的结果,以及安全漏洞。
   throw;
  }
  //不带参数的catch语句将捕捉所有类型的异常
  catch
  {
   //在这个catch块中放入那些能够从任何类型的异常中恢复的代码。
   //捕捉到的任何一个异常时,都应该将其重新抛出,否则、异常处理可能隐藏代码中的一些严重的问题。
   //如果捕捉了这个异常,然后又忽略它并继续执行应用程序,应用程序可能产生无法预料的结果/行为,以及安全漏洞(安全脆弱性)。
   throw;
  }

  finally
  {
   //在finally块中包含的代码不管try块中或catch块中是否产生异常都是确保要执行的代码。
   //通常放入对try块中的动作所需资源进行清理操作的代码,以确保资源清理代码一定得到执行。

   //应该避免将可能抛出异常的代码放在finally块中。
   //如果在finally块中抛出异常,则将屏蔽掉try块中或catch块中所产生的异常,并将finally块内的异常传播到调用try块的上一级(上一级try块或上一级方法)
  }
  //如果try块没有抛出异常,或者某个catch块捕捉了异常且没有抛出别的异常或重新抛出捕捉到的异常,那末就执行finally块后面的代码。
 }
}

//throw语句:throw [异常类的对象]
//          1)如果在函数内部,则引发函数内部的异常
//           2)如果在try块中,则引发try块内的异常
//           3)如果在catch块中,使用throw语句可以重新抛出已捕获的异常类的对象,使用throw new异常类()语句可以抛出新的异常类的对象,
//                               则引发catch块内的异常,并将异常对象传播到调用try块的上一级(上一级try块或上一级方法)
//           4)如果在finally块中,则引发finally块内的异常,同时屏蔽掉try块中或catch块中所产生的异常,并将finally块内的异常对象传播到调用try块的上一级(上一级try块或上一级方法)


//返回值方式的异常处理:程序调用没有统一的固定标准,有的使用HRESULT,有的使用bool,还有使用其它方式的。
//必须在异常发生的地方捕捉或者检测它们。
//传统的错误处理一直是影响程序设计质量的一个瓶颈。
//bool success = CallFunction();
//if(!success)
//{
 //错误处理
//}
//由于没有经验或疏忽,只写如下代码:所有的异常都会被直接抛弃,就产生了bug。
//CallFunction();


//类库开发人员正确地使用异常,应该严格遵循的指导原则:
//1.(方法的参数)验证方法的参数:
//  1)在重用类中实现方法时,在方法的入口点处应验证它的参数,而且对于任何无效的参数,方法应抛出一个派生自System.ArgumentException的异常类型。
//     从System.ArgumentException派生的最有用的异常类型就是System.ArgumentNullException、System.ArgumentOutOfRangeException、
//     System.ArgumentDuplicateWaitObjectException。如果未使用这三个异常类型,则可定义派生自System.ArgumentException的异常类型,
//     或者简单地抛出一个System.ArgumentException异常对象。
//  2)当方法接受引用类型的参数时,参数引用的实际对象可以被方法外的代码改变(例如在多线程中)。为了构建一个安全的、健壮的类库,
//     接受引用类型参数的方法应复制这些参数,接着在验证这些参数的副本,最后在方法内部使用该副本。

//2.(finally块)合理使用finally块:清理成功启动的操作,显式地释放对象以避免资源泄漏。

//3.(catch语句)避免捕捉所有的异常:
//  1)捕捉一个异常时,表明该异常是我们能预料到的异常,能理解它为什么发生,并且知道如何修复处理它。

//  2)如果类型是类库的一部分,绝对不应该捕捉并忽略所有的异常,因为不可能知道应用程序如何处理这些异常。
//  3)如果类库的代码捕捉并忽略该异常,应用程序就会继续执行,应用程序可能产生无法预料的结果/行为,以及安全漏洞(安全脆弱性)。
//  4)类库的代码不应捕捉System.Exception异常和其它基类异常。如果这样做,则意味着将所有的具体异常类型都转换成了一个单一的异常类型。
//     这会丢失所有有意义的异常类型信息
// 
//  5)如果应用程序检测到无法恢复的异常,而允许应用程序继续运行,可能导致无法预测的行为或者安全脆弱性。就不应该抛出异常,相反应用程序应该强迫进程立即终止。
//
//4.(catch块)从异常中顺利恢复。
//5.(catch块)当异常无法修复是,可回滚局部完成的操作。
//6.(catch块)

 

 

 


......

[阅读全文]

protected

using System;

namespace _protected
{
 //----------------实例成员的受保护访问
 // 当在声明了某个 protected 实例成员的类的程序文本之外访问该实例成员时,
 // 以及当在包含有某个 protected internal 实例成员声明的程序的程序文本之外访问该实例成员时,
 // 要求这种访问发生在该成员所属类的一个派生类的程序文本中,并引用该派生类的一个实例。

 // 假定 B 是一个基类,它声明了一个受保护的实例成员 M,而 D 是从 B 派生的类。

 // 在 B 的类体中,对 M 的访问可采取下列形式之一:
 //
 // M 形式的非限定类型名或初等表达式。 (this.M)
 // F.M 形式的初等表达式(其中,F 是类 B 或是从 B 派生的类)。


 // 在 D 的类体中,对 M 的访问可采取下列形式之一:
 //
 // M 形式的非限定类型名或初等表达式。 (this.M)
 // E.M 形式的初等表达式(其中,E 是类 D 或是从 D 派生的类)。
 // base.M 形式的初等表达式。
 //    (由于base关键字具有特殊的含义,编译器可以判断出base引用的一定是基类的派生类的实例base = (B)D)
 //
 // 在 D 的类体中,对 M 的访问不可采取下列形式:
 //
 //  B.M   不能通过基类型的变量(与基类型的变量所引用的实例类型无关)引用保护成员
 //  编译器无法判断B引用的是B的实例,还是B的派生类D的实例

 public class A
 {
  protected int x;

  protected void ABase()
  {
   Console.WriteLine(this.GetType());
  }

  public  A()
  {
  }

  public void F()
  {
   A a = new A();
   B b = new B();
   C c = new C();
   A ab = b;
   A ac = c;

   x = 0;
   this.x = 0;

   a.x =1;
   b.x = 1;
   c.x =2;
   ab.x = 3;
   ac.x = 3;
  }  
 }


 // 在 A 中可以通过 A 和 B 的实例访问 x,这是因为在两种情况下访问都通过 A 的实例或从 A 派生的类发生。
 // 但是在 B 中,由于 A 不从 B 派生,所以不可能通过 A 的实例访问 x。

 


 public class B: A
 {
  int y;

  public new void F()
  {
   A a = new A();
   B b = new B();
   C c = new C();
   A ab = b;
   A ac = c;

   x = 0;
   this.x = 0;
   b.x = 1;
   c.x =2;

   //编译器无法判断a、ab、ac引用的是A的实例,还是A的派生类B、C的实例
   //   a.x =1;
   //   ab.x = 3;
   //   ac.x = 3;

   //由于base关键字具有特殊的含义,编译器可以判断出base引用的一定是基类的派生类的实例
   base.x = 1;
   base.ABase();

   //   Console.WriteLine(base.GetType());
   //   Console.WriteLine(this.GetType());

  }
 }

 public class C: B
 {
  int z;

  public new void F()
  {
   A a = new A();
   B b = new B();
   C c = new C();
   A ab = b;
   A ac = c;

   x = 0;
   this.x = 0;
   c.x =2;
   //   a.x =1;
   //   b.x = 1;
   //   ab.x = 3;
   //   ac.x = 3;

   base.x = 2;
   base.ABase();
  }
 }

 

 /// <summary>
 /// Class1 的摘要说明。
 /// </summary>
 class class1
 {
  /// <summary>
  /// 应用程序的主入口点。
  /// </summary>
  [STAThread]
  static void Main(string[] args)
  {
   A a = new A();
   B b = new B();
   C c = new C();

   a.F();
   b.F();
   c.F();


  }
 }
}


......

[阅读全文]

FileStream类型重写Dispose方法

文件流释放句柄后,才可以再对文件进行删除操作
---------------------------------------------------------------------------------------------
#define Version1
using System;
using System.IO;

//范例:FileStream类型派生自实现了Close方法和无参的IDisposable.Dispose方法的Stream类型,
//  FileStream类型简单重写了Dispose方法,它接受一个Boolean参数来释放Handle字段包装的非托管文件资源。

public sealed class Program
{
#if Version1
   public static void Main() {
      // Create the bytes to write to the temporary file.
      Byte[] bytesToWrite = new Byte[] { 1, 2, 3, 4, 5 };

      // Create the temporary file.
      FileStream fs = new FileStream("Temp.dat", FileMode.Create);

      // Write the bytes to the temporary file.
      fs.Write(bytesToWrite, 0, bytesToWrite.Length);

      // Explicitly close the file when done writing to it.
    //如果注释掉下面一行,则文件基本上不可能删除。
    ((IDisposable) fs).Dispose();

      // Delete the temporary file.
      File.Delete("Temp.dat");  // This always works now
   }
#endif


#if Version2
 public static void Main()
 {
  // Create the bytes to write to the temporary file.
  Byte[] bytesToWrite = new Byte[] { 1, 2, 3, 4, 5 };

  // Create the temporary file.
  FileStream fs = new FileStream("Temp.dat", FileMode.Create);
  try
  {
   // Write the bytes to the temporary file.
   fs.Write(bytesToWrite, 0, bytesToWrite.Length);
  }
  finally
  {
   // Explicitly close the file when done writing to it.
   if (fs != null)
    ((IDisposable)fs).Dispose();//或者fs.Close();
  }

  // Delete the temporary file.
  File.Delete("Temp.dat");  // This always works now.
 }
#endif


}


......

[阅读全文]

IFormattable

using System;
using System.Text;
using System.Threading;

public static class Program
{
    public static void Main()
    {
        StringBuilder sb = new StringBuilder();
        sb.AppendFormat(new BoldInt32s(), "{0} {1} {2:M}", "Jeff", 123, DateTime.Now);
        Console.WriteLine(sb);
    }
}

internal sealed class BoldInt32s : IFormatProvider, ICustomFormatter
{
    public Object GetFormat(Type formatType)
    {
        if (formatType == typeof(ICustomFormatter)) return this;
        return Thread.CurrentThread.CurrentCulture.GetFormat(formatType);
    }

    public String Format(String format, Object arg, IFormatProvider formatProvider)
    {
        String s;

        IFormattable formattable = arg as IFormattable;

        if (formattable == null) s = arg.ToString();
        else s = formattable.ToString(format, formatProvider);

        if (arg.GetType() == typeof(Int32))
            return "<B>" + s + "</B>";
        return s;
    }
}


......

[阅读全文]

string.format

//将多个对象格式化成单个字符串

//1)String.Format 方法
//2)StringBuilder.AppendFormat 方法
//3)Console.WriteLine 方法 或Console.Write 方法
using System;
using System.Collections.Generic;
using System.Text;

class Program
{
    static void Main(string[] args)
    {
        //在内部,Format方法解析格式字符串,对每一个对象,
        //1)如果实现了System.IFormattable接口,则应调用IFormattable接口的ToString方法,返回该对象的格式字符串。
        //2)如果未实现System.IFormattable接口,则应调用无参数的ToString()方法,返回该对象的格式字符串。
        //3)将返回的格式字符串依此连接到一起,并返回最终得到的完整字符串。

        string s = String.Format("On {0}, {1} is {2} years lod.", new DateTime(2006, 4, 22, 14, 35, 5), "Aidan", 3);
        Console.WriteLine(s);

        s = String.Format("On {0:D}, {1} is {2:E} years lod.", new DateTime(2006, 4, 22, 14, 35, 5), "Aidan", 3);
        Console.WriteLine(s);

    }
}


......

[阅读全文]

SpringWidgets制作过程

widgets收录有blogger朋友们,可以去http://www.springwidgets.com/做一个属于自己的Widgets,在这里我可以给大家展示出来,以此来链接所有的blogger友们,现在所有博客都收录
1.大家可以输入下面的网址得到这个

2.接着大家输入自己的博客地址或者是自己的Rss地址都行
 
3.点提交后就会出现以下界面(注意Show Titles Only选项选中然后
4.Publish My Widget点击这个按钮发布自己的widget (如果自己没有注册,可以注册一个用户,以后就可以制作了)
5.最后一点获得自己的代码(点击share this Widget)
6.出现如下界面
7.点击B图标
8.看到了吧get Code复制自己的代码就好了,现在你可以
输入http://bilplink.blogspot.com来让共享你的博客了,让所有的人都来分享你的博客
 
 
 
 

......

[阅读全文]

ICustomFormatter

//获取对象的字符串表示:将一个对象格式化成字符串。

//FCL的设计者提出了一个统一范式。可以调用ToString方法来获取任何对象的字符串表示。
//每个类型都有责任提供相应的代码来将一个实例的值转换成字符串。

//public、virtual、无参数的ToString()方法:
//1)使用默任的“G”格式
//2)使用默任的当前线程文化
//3)通常调用ToString(null,null)
//任何类型如果希望提供一个合理的方式来获取对象当前值的字符串表示,都应该重写ToString()方法。
//FCL内建的所有基类型(Int32,Double,Decimal,DateTime等)都重写了它们的ToString()方法。
//问题:
//1)调用者无法控制字符串的格式。
//2)调用者不能选择一种特定的语言文化来格式化一个字符串。

//类型实现System.IFormattable接口,调用者就能够选择精确的格式和语言文化。
//FCL内建的所有基类型(Int32,Double,Decimal,DateTime等)都实现了System.IFormattable接口
//每个枚举类型定义都将自动实现System.IFormattable接口,以便根据枚举类型的一个实例来获取一个有意义的字符串。
//
//System.IFormattable接口的ToString方法:使用指定的格式和文化格式化当前实例的值。
//string ToString ( string format, IFormatProvider formatProvider)
//format(格式):指定要使用的格式,告诉方法应该如何格式化对象。
//                  空引用,表示使用为 IFormattable 实现的类型定义的默认格式(“G”格式)。
//                  默认格式:实现一个类型时,自己认为最常用的一种格式。
//formatProvider(格式提供者):它引用实现了用于格式化该值的System. IFormatProvider接口的一个类型的实例。
//                              为ToString方法提供了具体的语言文化信息。
//                                空引用,使用与当前调用线程关联的语言文化信息。
//
//负责实现“System.IFormatProvider接口的ToString方法”的类型要决定哪些格式字符串能够被识别。
//假如传递的格式字符串无法被类型识别,类型应该抛出一个System.FormatException异常。

// IFormatProvider接口的基本思路是:假如一个类型实现了该接口,就认为类型的一个实例能够提供依赖于语言文化的格式化信息,
//                                  而与当前调用线程关联的语言文化信息应被抛弃。提供用于检索控制格式化的对象的机制。
//Object GetFormat (Type formatType)
//GetFormat方法,以获得(1)提供格式信息的格式化对象或(2)实现类型处理的对象。
//                如果格式说明符的含义因区域性而异,则格式化对象提供字符串表示形式中所用的实际字符。
//GetFormat方法 的参数 formatType  能够识别任何类型,允许请求任何类型的格式化信息。
//                                 在.NET中,类型在调用时,暂时只会请求数字或日期/时间信息。                       
//
//在FCL中,只有三个类型NumberFormatInfo、DateTimeFormatInfo 和 CultureInfo 实现 IFormatProvider 接口。
//NumberFormatInfo 提供数字格式信息,如用于小数分隔符和千位分隔符的字符,以及货币值中货币符号的拼写和位置。
//DateTimeFormatInfo 提供与日期相关和与时间相关的格式信息,如日期模式中月、日和年的位置。
//CultureInfo 包含特定区域性中的默认格式信息,其中包括数字格式信息以及与日期相关和与时间相关的格式信息。
//
//在一个NumberFormatInfo对象实例上调用GetFormat(typeof(NumberFormatInfo))方法时,该方法会核实被请求的类型是不是NumberFormatInfo。
//      如果是,就返回this;否则,返回null。
//在一个DateTimeFormatInfo对象实例上调用GetFormat(typeof(DateTimeFormatInfo))方法时,该方法会核实被请求的类型是不是DateTimeFormatInfo。
//      如果是,就返回this;否则,返回null。
//这两个类实现IFormatProvider 接口,纯粹是为了简化编程。

//ToString方法格式化数字(Int32,Double,Decimal等)
//1)如果 formatProvider == null,则
//        formatProvider = System.ThreadingThread.CurrentThread.CurrentCulture
//        获得System.Globalization.CultureInfo 类型的一个与当前调用线程关联的提供格式信息的格式化对象
//2)如果 formatProvider <> null,则
//        NumberFormatInfo nfi = (NumberFormatInfo)formatProvider.GetFormat(typeof(NumberFormatInfo));
//        返回NumberFormatInfo类型的格式化对象nfi
//3)如果 format = null,则
//        format = "G"
//4)在构造并格式化一个字符串的时候,读取格式化对象nfi的属性,获取恰当的数字格式化信息。
//     如果格式说明符的含义因区域性而异,则格式化对象提供字符串表示形式中所用的实际字符。     

//ToString方法格式化日期/时间(DateTime)
//1)如果 formatProvider == null,则
//        formatProvider = System.ThreadingThread.CurrentThread.CurrentCulture
//        获得System.Globalization.CultureInfo 类型的一个与当前调用线程关联的提供格式信息的格式化对象
//2)如果 formatProvider <> null,则
//        DateTimeFormatInfo dtfi = (DateTimeFormatInfo)formatProvider.GetFormat(typeof(DateTimeFormatInfo));
//        返回DateTimeFormatInfo类型的格式化对象dtfi
//3)如果 format = null,则
//        format = "G"
//4)在构造并格式化一个字符串的时候,读取格式化对象dtfi的属性,获取恰当的日期/时间格式化信息。
//      如果格式说明符的含义因区域性而异,则格式化对象提供字符串表示形式中所用的实际字符。

 //Decimal类型提供了四个不同的ToString方法
//1)public override ToString();//调用ToString(null,null)
//2)public String ToString ( string format, IFormatProvider formatProvider);
//3)public String ToString ( string format);//调用ToString(format,null)
//4)public String ToString ( IFormatProvider formatProvider);//调用ToString(null,formatProvider)

//客户端通常使用当前线程的语言文化信息来格式化一个字符串。
//服务器端使用不变的文化(System.Globalization.CultureInfo的静态属性 InvariantCulture)来格式化一个字符串,
//  并将其保存在一个数据文件中,以便将来对其进行解析。
//


using System;
using System.Collections.Generic;
using System.Text;
using System.Globalization;


class Point : IFormattable
{
    public int x, y;

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

    public override String ToString() { return ToString(null, null); }

    public String ToString(String format, IFormatProvider fp)
    {
        // If no format is passed, display like this: (x, y).
        if (format == null) return String.Format("({0}, {1})", x, y);

        // For "x" formatting, return just the x value as a string
        if (format == "x") return x.ToString();

        // For "y" formatting, return just the y value as a string
        if (format == "y") return y.ToString();

        // For any unrecognized format, throw an exception.
        throw new FormatException(String.Format("Invalid format string: '{0}'.", format));
    }
}


public sealed class App
{
    static void Main()
    {
        //Culture
        Decimal price = 123.54M;
        //越南文化
        String s = price.ToString("C", new CultureInfo("vi-VN"));
        Console.WriteLine(s);

        //不变文化
        s = price.ToString("C", CultureInfo.InvariantCulture);
        Console.WriteLine(s);


        // Create the object.
        Point p = new Point(5, 98);

        // Test ToString with no formatting.
        Console.WriteLine("This is my point: " + p.ToString());

        // Use custom formatting style "x"
        Console.WriteLine("The point's x value is {0:x}", p);

        // Use custom formatting style "y"
        Console.WriteLine("The point's y value is {0:y}", p);

        try
        {
            // Use an invalid format; FormatException should be thrown here.
            Console.WriteLine("Invalid way to format a point: {0:XYZ}", p);
        }
        catch (FormatException e)
        {
            Console.WriteLine("The last line could not be displayed: {0}", e.Message);
        }
    }
}

// This code produces the following output.
//
//  This is my point: (5, 98)
//  The point's x value is 5
//  The point's y value is 98
//  The last line could not be displayed: Invalid format string: 'XYZ'.


 


......

[阅读全文]

string

(文本)字符串:字符串是 Unicode 字符的有序集合,用于表示文本。

Unicode 字符

Unicode编码: (抽象的)Unicode 字符(或叫文本字符):由码位标识(21 位标量数字)。

Unicode编码的实现:

UTF-16 编码格式:将码位编码为一个或多个 16 位值的序列,每个 16 位值的范围为十六进制的 0x0000 到 0xFFFF,并存储在 Char 结构中。

多数 (抽象的)Unicode 字符可由一个 Char 对象表示,但编码为基字符、代理项对和/或组合字符序列的字符由多个 Char 对象表示。

String 对象(字符串的实现):是 System.Char 对象的有序集合,用于表示字符串。

Char 对象:Char 对象的值是 16 位数字(序号)值。



代理项对和组合字符序列的 Unicode 支持

“Unicode 标准”将代理项对定义为由两个代码单元序列组成的单个抽象字符的编码字符表示形式。代理项对的第一个值是高代理项,它包含一个介于 U+D800 到 U+DBFF 之间的 16 位代码值。代理项对的第二个值是低代理项,它包含介于 U+DC00 到 U+DFFF 之间的值。通过使用代理项对,16 位 Unicode 编码系统可以对已由 Unicode 标准定义的一百多万个其他字符 (220) 进行寻址。代理项对扩展字符集之外 Unicode 字符。

“Unicode 标准”将组合字符序列定义为一个基字符与一个或多个组合字符的组合。代理项对可表示基字符或组合字符。有关代理项对和组合字符序列的更多信息,请参见位于 www.unicode.org 的 Unicode Standard(Unicode 标准)。

需要记住的关键一点是代理项对表示 32 位单个字符,不能假定一个 16 位 Unicode 编码值恰好映射为一个字符。通过使用代理项对,16 位 Unicode 编码系统可以表示另外一百万个代码数据点,而 Unicode 标准将为它们分配字符。

.NET Framework 支持文本元素。文本元素是显示为单字符的文本单元,称作字素。文本元素可以是基字符、代理项对或组合字符序列。StringInfo 类提供了一些方法,使您可以将字符串拆分为文本元素,并循环访问这些文本元素。例如,StringInfo.GetNextTextElement 方法允许将一个代理项对作为一个文本元素来检索。有关使用 StringInfo 类的示例,请参见字符串索引。





字符串是 Unicode 字符的有序集合,用于表示文本。(字符串的实现)String 对象是 System.Char 对象的有序集合,用于表示字符串。String 对象的值是该有序集合的内容,并且该值是不可变的。

String 对象称为不可变的(只读),因为一旦创建了该对象,就不能修改该对象的值。看来似乎修改了 String 对象的方法实际上是返回一个包含修改内容的新 String 对象。如果需要修改字符串对象的实际内容,请使用 System.Text.StringBuilder 类。

字符串中的每个 Unicode 字符都是由 Unicode 标量值定义的,Unicode 标量值也称为 Unicode 码位或者 Unicode 字符的序号(数字)值。每个码位都是使用 UTF-16 编码进行编码的,编码的每个元素的数值都用一个 Char 对象表示。

一个 Char 对象通常表示一个码位,即:Char 的数值等于该码位。但是,一个码位可能需要多个编码元素。例如,Unicode 辅助码位(代理项对)使用两个 Char 对象来编码。

索引

索引是 Char 对象在 String 中的位置,而不是 Unicode 字符的位置。索引是从零开始、从字符串的起始位置(其索引为零)计起的非负数字。连续的索引值可能并不与连续的 Unicode 字符相对应,这是因为一个 Unicode 字符可能会编码为多个 Char 对象。若要使用每个 Unicode 字符而不是每个 Char 对象,请使用 System.Globalization.StringInfo 类。

序号运算和区分区域性的运算

String 类的成员对 String 对象执行序号运算或语义运算。序号运算是对每个 Char 对象的数值执行的。语义运算则对考虑了特定于区域性的大小写、排序、格式化和语法分析规则的 String 的值执行。语义运算在显式声明的区域性或者隐式当前区域性的上下文中执行。有关当前区域性的更多信息,请参见 CultureInfo.CurrentCulture 主题。

大小写规则决定如何更改 Unicode 字符的大小写,例如,从小写变为大写。

格式化规则决定如何将值转换为它的字符串表示形式,而语法分析规则则确定如何将字符串表示形式转换为值。

排序规则确定 Unicode 字符的字母顺序,以及两个字符串如何互相比较。例如,Compare 方法执行语义比较,而 CompareOrdinal 方法执行序号比较。因此,如果当前的区域性为美国英语,则 Compare 方法认为“a”小于“A”,而 CompareOrdinal 方法会认为“a”大于“A”。

.NET Framework 支持单词、字符串和序号排序规则。单词排序会执行区分区域性的字符串比较,在这种比较中,某些非字母数字 Unicode 字符可能会具有特殊的权重。例如,连字符(“-”)的权重非常小,因此“coop”和“co-op”在排序列表中是紧挨着出现的。字符串排序与单词排序相似,只是所有非字母数字符号均排在所有字母数字 Unicode 字符前面,没有特例。

区分区域性的比较是显式或隐式使用 CultureInfo 对象的任何比较,包括由 CultureInfo.InvariantCulture 属性指定的固定区域性。当前隐式区域性由 Thread.CurrentCulture 属性指定。

序号排序基于字符串中每个 Char 对象的数值对字符串进行比较。序号比较自动区分大小写,因为字符的小写和大写版本有着不同的码位。但是,如果大小写在应用程序中并不重要,则可以指定忽略大小写的序号比较。这等效于使用固定区域性将字符串转换成大写,然后对结果执行序号比较。

有关单词、字符串和序号排序规则的更多信息,请参见 System.Globalization.CompareOptions 主题。

区分区域性的比较通常适用于排序,而序号比较则不适合。序号比较通常适用于确定两个字符串是否相等(即,确定标识),而区分区域性的比较则不适用。

比较和搜索方法的“备注”指定方法是区分大小写、区分区域性还是两者区分。根据定义,任何字符串(包括空字符串 (""))的比较结果都大于空引用;两个空引用的比较结果为相等。

规范化

某些 Unicode 字符具有多个等效的二进制表示形式,这些表示形式中包含几组组合的和/或复合的 Unicode 字符。Unicode 标准定义了一个称为规范化的过程,此过程将一个字符的任何一种等价二进制表示形式转换为统一的二进制表示形式。可使用多种遵循不同规则的算法执行规范化,这些算法也称为范式。.NET Framework 当前支持范式 C、D、KC 和 KD。通常用序号比较来评估一对规范化的字符串。

安全注意事项

如果应用程序进行有关符号标识符(如文件名或命名管道)或持久数据(如 XML 文件中基于文本的数据)的安全决策,则该操作应该使用序号比较而不是区分区域性的比较。这是因为根据起作用的区域性的不同,区分区域性的比较可产生不同的结果,而序号比较则仅依赖于所比较字符的二进制值。


字符串留用


公共语言运行库通过维护一个表来存放字符串,该表称为拘留池,它包含程序中以编程方式声明或创建的每个唯一的字符串的一个引用。因此,具有特定值的字符串的实例在系统中只有一个。

例如,如果将同一字符串分配给几个变量,运行库就会从拘留池中检索对该字符串的相同引用,并将它分配给各个变量。

Intern 方法使用拘留池来搜索与 str 值相等的字符串。如果存在这样的字符串,则返回拘留池中它的引用。如果不存在,则向拘留池添加对 str 的引用,然后返回该引用。

在下面的 C# 示例中,值为“MyTest”的字符串 s1 已经留用,因为它在程序中是一个字符串常量。

System.Text.StringBuilder 类生成与 s1 同值的新字符串对象。对该字符串的引用被分配给 s2。

Intern 方法搜索与 s2 具有相同值的字符串。由于存在这样的字符串,该方法会返回分配给 s1 的同一引用,然后将该引用分配给 s3。

引用 s1 和 s2 的比较结果是不相等的,这是因为它们引用的是不同的对象;而引用 s1 和 s3 的比较结果是相等的,因为它们引用的是相同的字符串。

 

复制代码

String s1 = "MyTest";

String s2 = new StringBuilder().Append("My").Append("Test").ToString();

String s3 = String.Intern(s2);

Console.WriteLine((Object)s2==(Object)s1); // Different references.

Console.WriteLine((Object)s3==(Object)s1); // The same reference



......

[阅读全文]

Globalization区域性

区域性名称和标识符

区域性名称遵循 RFC 1766 标准,格式为“<languagecode2>-<country/regioncode2>”,其中 <languagecode2> 是从 ISO 639-1 派生的由两个小写字母构成的代码,<country/regioncode2> 是从 ISO 3166 派生的由两个大写字母构成的代码。例如,美国英语为“en-US”。在双字母语言代码不可用的情况中,将使用从 ISO 639-2 派生的三字母代码;例如,三字母代码“div”用于使用 Dhivehi 语言的区域。某些区域性名称带有指定书写符号的后缀;例如“-Cyrl”指定西里尔语书写符号,“-Latn”指定拉丁语书写符号。

System.Globalization 命名空间中的此类和其他类接受并使用下列预定义的区域性名称和标识符。

区域性名称

区域性标识符

语言-国家/地区

""(空字符串)

0x007F

固定区域性

af

0x0036

南非荷兰语

af-ZA

0x0436

南非荷兰语 - 南非

sq

0x001C

阿尔巴尼亚语

sq-AL

0x041C

阿尔巴尼亚语 - 阿尔巴尼亚

ar

0x0001

阿拉伯语

ar-DZ

0x1401

阿拉伯语 - 阿尔及利亚

ar-BH

0x3C01

阿拉伯语 - 巴林

ar-EG

0x0C01

阿拉伯语 - 埃及

ar-IQ

0x0801

阿拉伯语 - 伊拉克

ar-JO

0x2C01

阿拉伯语 - 约旦

ar-KW

0x3401

阿拉伯语 - 科威特

ar-LB

0x3001

阿拉伯语 - 黎巴嫩

ar-LY

0x1001

阿拉伯语 - 利比亚

ar-MA

0x1801

阿拉伯语 - 摩洛哥

ar-OM

0x2001

阿拉伯语 - 阿曼

ar-QA

0x4001

阿拉伯语 - 卡塔尔

ar-SA

0x0401

阿拉伯语 - 沙特阿拉伯

ar-SY

0x2801

阿拉伯语 - 叙利亚

ar-TN

0x1C01

阿拉伯语 - 突尼斯

ar-AE

0x3801

阿拉伯语 - 阿拉伯联合酋长国

ar-YE

0x2401

阿拉伯语 - 也门

hy

0x002B

亚美尼亚语

hy-AM

0x042B

亚美尼亚语 - 亚美尼亚

az

0x002C

阿泽里语

az-AZ-Cyrl

0x082C

阿泽里语(西里尔语)- 阿塞拜疆

az-AZ-Latn

0x042C

阿泽里语(拉丁)- 阿塞拜疆

eu

0x002D

巴斯克语

eu-ES

0x042D

巴斯克语 - 巴斯克地区

be

0x0023

白俄罗斯语

be-BY

0x0423

白俄罗斯语 - 白俄罗斯

bg

0x0002

保加利亚语

bg-BG

0x0402

保加利亚语 - 保加利亚

ca

0x0003

加泰罗尼亚语

ca-ES

0x0403

加泰罗尼亚语 - 加泰罗尼亚地区

zh-HK

0x0C04

中文 - 香港特别行政区

zh-MO

0x1404

中文 - 澳门特别行政区

zh-CN

0x0804

中文 - 中国

zh-CHS

0x0004

中文(简体)

zh-SG

0x1004

中文 - 新加坡

zh-TW

0x0404

中文 - 台湾

zh-CHT

0x7C04

中文(繁体)

hr

0x001A

克罗地亚语

hr-HR

0x041A

克罗地亚语 - 克罗地亚

cs

0x0005

捷克语

cs-CZ

0x0405

捷克语 - 捷克共和国

da

0x0006

丹麦语

da-DK

0x0406

丹麦语 - 丹麦

div

0x0065

马尔代夫语

div-MV

0x0465

马尔代夫语 - 马尔代夫

nl

0x0013

荷兰语

nl-BE

0x0813

荷兰语 - 比利时

nl-NL

0x0413

荷兰语 - 荷兰

en

0x0009

英语

en-AU

0x0C09

英语 - 澳大利亚

en-BZ

0x2809

英语 - 伯利兹

en-CA

0x1009

英语 - 加拿大

en-CB

0x2409

英语 - 加勒比

en-IE

0x1809

英语 - 爱尔兰

en-JM

0x2009

英语 - 牙买加

en-NZ

0x1409

英语 - 新西兰

en-PH

0x3409

英语 - 菲律宾

en-ZA

0x1C09

英语 - 南非

en-TT

0x2C09

英语 - 特立尼达和多巴哥

en-GB

0x0809

英语 - 英国

en-US

0x0409

英语 - 美国

en-ZW

0x3009

英语 - 津巴布韦

et

0x0025

爱沙尼亚语

et-EE

0x0425

爱沙尼亚语 - 爱沙尼亚

fo

0x0038

法罗语

fo-FO

0x0438

法罗语 - 法罗群岛

fa

0x0029

波斯语

fa-IR

0x0429

波斯语 - 伊朗

fi

0x000B

芬兰语

fi-FI

0x040B

芬兰语 - 芬兰

fr

0x000C

法语

fr-BE

0x080C

法语 - 比利时

fr-CA

0x0C0C

法语 - 加拿大

fr-FR

0x040C

法语 - 法国

fr-LU

0x140C

法语 - 卢森堡

fr-MC

0x180C

法语 - 摩纳哥

fr-CH

0x100C

法语 - 瑞士

gl

0x0056

加利西亚语

gl-ES

0x0456

加利西亚语 - 加利西亚地区

ka

0x0037

格鲁吉亚语

ka-GE

0x0437

格鲁吉亚语 - 格鲁吉亚

de

0x0007

德语

de-AT

0x0C07

德语 - 奥地利

de-DE

0x0407

德语 - 德国

de-LI

0x1407

德语 - 列支敦士登

de-LU

0x1007

德语 - 卢森堡

de-CH

0x0807

德语 - 瑞士

el

0x0008

希腊语

el-GR

0x0408

希腊语 - 希腊

gu

0x0047

古吉拉特语

gu-IN

0x0447

古吉拉特语 - 印度

he

0x000D

希伯来语

he-IL

0x040D

希伯来语 - 以色列

hi

0x0039

印地语

hi-IN

0x0439

印地语 - 印度

hu

0x000E

匈牙利语

hu-HU

0x040E

匈牙利语 - 匈牙利

is

0x000F

冰岛语

is-IS

0x040F

冰岛语 - 冰岛

id

0x0021

印度尼西亚语

id-ID

0x0421

印度尼西亚语 - 印度尼西亚

it

0x0010

意大利语

it-IT

0x0410

意大利语 - 意大利

it-CH

0x0810

意大利语 - 瑞士

ja

0x0011

日语

ja-JP

0x0411

日语 - 日本

kn

0x004B

卡纳达语

kn-IN

0x044B

卡纳达语 - 印度

kk

0x003F

哈萨克语

kk-KZ

0x043F

哈萨克语 - 哈萨克斯坦

kok

0x0057

贡根语

kok-IN

0x0457

贡根语 - 印度

ko

0x0012

朝鲜语

ko-KR

0x0412

朝鲜语 - 韩国

ky

0x0040

吉尔吉斯语

ky-KG

0x0440

吉尔吉斯语 - 吉尔吉斯坦

lv

0x0026

拉脱维亚语

lv-LV

0x0426

拉脱维亚语 - 拉脱维亚

lt

0x0027

立陶宛语

lt-LT

0x0427

立陶宛语 - 立陶宛

mk

0x002F

马其顿语

mk-MK

0x042F

马其顿语 - 前南斯拉夫联盟马其顿共和国

ms

0x003E

马来语

ms-BN

0x083E

马来语 - 文莱

ms-MY

0x043E

马来语 - 马来西亚

mr

0x004E

马拉地语

mr-IN

0x044E

马拉地语 - 印度

mn

0x0050

蒙古语

mn-MN

0x0450

蒙古语 - 蒙古

no

0x0014

挪威语

nb-NO

0x0414

挪威语(伯克梅尔)- 挪威

nn-NO

0x0814

挪威语(尼诺斯克)- 挪威

pl

0x0015

波兰语

pl-PL

0x0415

波兰语 - 波兰

pt

0x0016

葡萄牙语

pt-BR

0x0416

葡萄牙语 - 巴西

pt-PT

0x0816

葡萄牙语 - 葡萄牙

pa

0x0046

旁遮普语

pa-IN

0x0446

旁遮普语 - 印度

ro

0x0018

罗马尼亚语

ro-RO

0x0418

罗马尼亚语 - 罗马尼亚

ru

0x0019

俄语

ru-RU

0x0419

俄语 - 俄罗斯

sa

0x004F

梵语

sa-IN

0x044F

梵语 - 印度

sr-SP-Cyrl

0x0C1A

塞尔维亚语(西里尔语)- 塞尔维亚

sr-SP-Latn

0x081A

塞尔维亚语(拉丁)- 塞尔维亚

sk

0x001B

斯洛伐克语

sk-SK

0x041B

斯洛伐克语 - 斯洛伐克

sl

0x0024

斯洛文尼亚语

sl-SI

0x0424

斯洛文尼亚语 - 斯洛文尼亚

es

0x000A

西班牙语

es-AR

0x2C0A

西班牙语 - 阿根廷

es-BO

0x400A

西班牙语 - 玻利维亚

es-CL

0x340A

西班牙语 - 智利

es-CO

0x240A

西班牙语 - 哥伦比亚

es-CR

0x140A

西班牙语 - 哥斯达黎加

es-DO

0x1C0A

西班牙语 - 多米尼加共和国

es-EC

0x300A

西班牙语 - 厄瓜多尔

es-SV

0x440A

西班牙语 - 萨尔瓦多

es-GT

0x100A

西班牙语 - 危地马拉

es-HN

0x480A

西班牙语 - 洪都拉斯

es-MX

0x080A

西班牙语 - 墨西哥

es-NI

0x4C0A

西班牙语 - 尼加拉瓜

es-PA

0x180A

西班牙语 - 巴拿马

es-PY

0x3C0A

西班牙语 - 巴拉圭

es-PE

0x280A

西班牙 - 秘鲁

es-PR

0x500A

西班牙语 - 波多黎各

es-ES

0x0C0A

西班牙语 - 西班牙

es-UY

0x380A

西班牙语 - 乌拉圭

es-VE

0x200A

西班牙语 - 委内瑞拉

sw

0x0041

斯瓦希里语

sw-KE

0x0441

斯瓦希里语 - 肯尼亚

sv

0x001D

瑞典语

sv-FI

0x081D

瑞典语 - 芬兰

sv-SE

0x041D

瑞典语 - 瑞典

syr

0x005A

叙利亚语

syr-SY

0x045A

叙利亚语 - 叙利亚

ta

0x0049

泰米尔语

ta-IN

0x0449

泰米尔语 - 印度

tt

0x0044

鞑靼语

tt-RU

0x0444

鞑靼语 - 俄罗斯

te

0x004A

泰卢固语

te-IN

0x044A

泰卢固语 - 印度

th

0x001E

泰语

th-TH

0x041E

泰语 - 泰国

tr

0x001F

土耳其语

tr-TR

0x041F

土耳其语 - 土耳其

uk

0x0022

乌克兰语

uk-UA

0x0422

乌克兰语 - 乌克兰

ur

0x0020

乌尔都语

ur-PK

0x0420

乌尔都语 - 巴基斯坦

uz

0x0043

乌兹别克语

uz-UZ-Cyrl

0x0843

乌兹别克语(西里尔语)- 乌兹别克斯坦

uz-UZ-Latn

0x0443

乌兹别克语(拉丁)- 乌兹别克斯坦

vi

0x002A

越南语

vi-VN

0x042A

越南语 - 越南

固定区域性、非特定区域性和特定区域性

这些区域性通常分为三个集合:固定区域性、非特定区域性和特定区域性。

固定区域性不区分区域性。可以使用空字符串 ("") 按名称或者按区域性标识符 0x007F 来指定固定区域性。InvariantCulture 检索固定区域性的实例。它与英语语言关联,但不与任何国家/地区关联。它几乎可用在要求区域性的“全局化”命名空间中的所有方法中。

非特定区域性是与某种语言关联但不与国家/地区关联的区域性。特定区域性是与某种语言和某个国家/地区关联的区域性。例如,“fr”是非特定区域性,而“fr-FR”是特定区域性。注意,“zh-CHS”(简体中文)和“zh-CHT”(繁体中文)均为非特定区域性。

区域性有层次结构,即特定区域性的父级是非特定区域性,而非特定区域性的父级是 InvariantCulture。Parent 属性将返回与特定区域性关联的非特定区域性。

如果特定区域性的资源在系统中不可用,则使用非特定区域性的资源;如果非特定区域性的资源也不可用,那么使用主程序集中嵌入的资源。有关资源备用进程的更多信息,请参见“打包和部署资源”。

Windows API 中的区域性列表与 .NET Framework 中的区域性列表略有不同。例如,在 Windows API 中未提供带有区域性标识符 0x7C04 的非特定区域性 zh-CHT“中文(繁体)”。如果需要具备同 Windows 进行互操作的能力(例如,通过 p/invoke 机制),可使用在操作系统中定义的特定区域性。这样可以确保与等效的 Windows 区域设置保持一致,它们使用同一 LCID 进行标识。

只能为固定区域性或特定区域性创建 DateTimeFormatInfo 或 NumberFormatInfo,而不能为非特定区域性创建它们。

如果 DateTimeFormatInfo.Calendar 是 TaiwanCalendar,但 Thread.CurrentCulture 不是“zh-TW”,则 DateTimeFormatInfo.NativeCalendarName、DateTimeFormatInfo.GetEraName 和 DateTimeFormatInfo.GetAbbreviatedEraName 将返回一个空字符串 ("")。

Windows 区域设置

从 .NET Framework 2.0 版开始,CultureInfo 构造函数支持使用 Windows 区域设置(相当于区域性)自动生成 .NET Framework 中不存在的区域性。有关更多信息,请参见根据 Windows 区域设置生成区域性。

控制面板重写

用户可以通过“控制面板”中的“区域和语言选项”(或“区域选项”或“区域设置”)选择重写某些与 Windows 的当前区域性关联的值。例如,用户可能选择以另一种格式显示日期,或选择使用区域性默认设置以外的货币。

如果 UseUserOverride 为 true 并且指定的区域性与当前 Windows 的区域性匹配,则 CultureInfo 使用那些重写,包括以下属性的用户设置:由 DateTimeFormat 属性返回的 DateTimeFormatInfo 实例的属性以及由 NumberFormat 属性返回的 NumberFormatInfo 实例的属性。如果用户设置与 CultureInfo 的关联区域性不兼容(例如选定的日历不属于 OptionalCalendars 其中之一),则方法结果和属性值是未定义的。

对于使用欧元的区域性,.NET Framework 和 Windows XP 将默认货币设置为欧元;但是,旧版本的 Windows 却不是这样。因此,如果旧版本 Windows 的用户未通过“控制面板”中的“区域选项”或“区域设置”更改货币设置,则货币可能不正确。若要使用 .NET Framework 的货币的默认设置,请使用接受 useUserOverride 参数的 CultureInfo 构造函数重载,并将该参数设置为 false。

备用排序顺序

“西班牙语 - 西班牙”的区域性标识符“0x0c0a”使用默认的国际排序顺序;而区域性标识符“0x040A”(也指“西班牙语 - 西班牙”)则使用传统排序顺序。如果使用“es-ES”区域性名称构造 CultureInfo,则新的 CultureInfo 将使用默认的国际排序顺序。要构造一个使用传统排序顺序的 CultureInfo,可在构造函数中使用区域性标识符“0x040A”。有关具有备用排序方法的其他区域性的更多信息,请参见“针对特定区域性对数据进行比较和排序”。

实现的接口

该类实现 ICloneable 接口以启用 CultureInfo 对象的复制。它还实现 IFormatProvider 以便为应用程序提供格式化信息。

主题

位置

如何:为 ASP.NET 网站创建资源文件

生成 ASP .NET Web 应用程序

如何:为 ASP.NET 网站创建资源文件 (Visual Studio)

在 Visual Studio 中构建 ASP .NET Web 应用程序

如何:为 ASP.NET 网页全球化设置区域性和 UI 区域性

生成 ASP .NET Web 应用程序

如何:以编程方式检索资源值

生成 ASP .NET Web 应用程序

如何:使用全球化 HTML 标记按从右到左的顺序显示文本

生成 ASP .NET Web 应用程序



......

[阅读全文]

友情链接

郑州大学软件学院 SpringWidgets-Blogger 徵信社 翻译公司 链接帮手网 行驶证字体 酷站目录 Friend Connectified