亚洲av成人一区二区三区在线播放 ,亚洲中文字幕无码爆乳AV,久久亚洲精品无码播放

C# 匿名�cȝ��定义

期待明天 — Mon, 26 Oct 2009 12:00:00 GMT

■匿名类:匿名�cȝ��来表�C�Z��时��用的只读数据�Q�所以必��d��创徏时初始化各字�D늚�数据�Q��ƈ且只能读取这些字�D늚��|��而不能设�|�这些字�D늚��?br /> 如：var val=new{StrVal="a String",IntVal=12};
val.StrVal
val.IntVal
val.ToString()

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace AnonymousClass
{
    class Program
    {
        static void Main(string[] args)
        {
            //定义匿名�c?/span>
            var val = new { StrVal = "HelloWorld", IntVal = 200 };
            System.Console.WriteLine("first variable is: {0};  theSecondVariable is:{1}",val.StrVal,val.IntVal);
            System.Console.WriteLine("val.ToString() is:{0}",val.ToString());
            System.Console.ReadLine();

        }
    }
}

�l�果�Q?br /> first variable is: HelloWorld; theSecondVariable is:200
val.ToString() is:{ StrVal = HelloWorld, IntVal = 200 }

期待明天 2009-10-26 20:00 发表评论

异常�c�Exception

期待明天 — Mon, 26 Oct 2009 11:06:00 GMT

■Exception�cȝ��主要成员�Q?br /> Exception:构造函敎ͼ�构造一个异常类�Q�制定其异常消息�Q�发生位�|?br /> Message�Q�只��d��性，获取当前异常提供的消息，该消息在构造异常时指定
Source�Q�读写属性，获取和设�|�引赯��异常的应用程序或对象的名�U?br /> TargetSite�Q�只��d��性，获取引发该异常的�Ҏ��
ToString�Q�公开�Ҏ��Q�创��异常的字�W�串表示形式�Q�包括异常发生的位置�Q�名�U�等信息

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ThrowException
{
    class Program
    {
        static void Main(string[] args)
        {
            try {
                ThrowAnException();
            }catch(Exception e){
                ShowException(e);
            }
            System.Console.ReadLine();
        }
        static void ThrowAnException() {
            throw new Exception("This is an Exception!");
        }
        static void ShowException(Exception e) {
            System.Console.WriteLine("An Exception information:");
            System.Console.WriteLine("Type:{0}  ",e.GetType().Name);
            System.Console.WriteLine("Message:{0}",e.Message);
            System.Console.WriteLine("Source:{0}",e.Source);
            System.Console.WriteLine("TargetSite:{0}",e.TargetSite);
            System.Console.WriteLine("ToString:{0}",e.ToString());
            System.Console.WriteLine("StackTrace:{0}",e.StackTrace);
        }
    }
}

�l�果�Q?br /> An Exception information:
......Type:Exception
......Message:This is an Exception!
......Source:ThrowException
......TargetSite:Void ThrowAnException()
......ToString:System.Exception: This is an Exception!
   �?ThrowException.Program.ThrowAnException() 位置 g:"TrueStudy"cSharp"project
s"ConsoleAppl"ThrowException"Program.cs:行号 20
   �?ThrowException.Program.Main(String[] args) 位置 g:"TrueStudy"cSharp"projec
ts"ConsoleAppl"ThrowException"Program.cs:行号 13
......StackTrace:   �?ThrowException.Program.ThrowAnException() 位置 g:"TrueStu
dy"cSharp"projects"ConsoleAppl"ThrowException"Program.cs:行号 20
   �?ThrowException.Program.Main(String[] args) 位置 g:"TrueStudy"cSharp"projec
ts"ConsoleAppl"ThrowException"Program.cs:行号 13

期待明天 2009-10-26 19:06 发表评论

C#异常

期待明天 — Mon, 26 Oct 2009 10:47:00 GMT

■异�怸�错误
异常是可预见�Q�可接受的，�E�序通过对异常的捕获和处理可以将异常带来的媄响减��到最��；
错误是程序代码的错误�Q�设计漏�z�，是不可预见的�Q�会�l��Y件带来致命的影响
■捕获异常：try...catch
■抛出异�?throw语句

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace useException
{
    class Program
    {
        static void Main(string[] args)
        {
            int val;
            for (int i = -3; i < 12; i++) {
                try {
                    val=GetValue(i);
                    System.Console.WriteLine("val:{0}",val);
                }catch(Exception e){
                    System.Console.WriteLine("exception:{0}: ",e.Message);
                }
            }
            System.Console.ReadLine();
        }
        static int GetValue(int index)
        {
            int[] ary = {0,1,2,3,4,5,6,7,8 };
            if (index < 0) {
                System.Console.Write("index={0}   ",index);
                throw new Exception("index<0");
            }
            if (index > 8){
                System.Console.Write("index={0}    ", index);
                throw new Exception("index>8");
            }
            return ary[index];
        }
    }
}

�l�果�Q?br />
index=-3   exception:index<0:
index=-2   exception:index<0:
index=-1   exception:index<0:
val:0
val:1
val:2
val:3
val:4
val:5
val:6
val:7
val:8
index=9    exception:index>8:
index=10    exception:index>8:
index=11    exception:index>8:

期待明天 2009-10-26 18:47 发表评论

C# 接口

期待明天 — Mon, 26 Oct 2009 10:21:00 GMT

■接口：使用关键字interface�Q�只是定义一�p�d��的行为类型，不提供�Q何实�?br /> interface IMovable{
   float speed{get;}
   float maxSpeed{get;set;}
   void Run()�Q?br />    void Walk();
   void Fly();
}
■接口的实现�Q�通过冒号来实�?br />

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace useInterface
{
    interface IMovable {
        float Speed{get;}
        float MaxSpeed { get; set; }
        void Run();
        void Walk();
        void Fly();
    }
    class Dog : IMovable {
        public float Speed {
            get {
                return 10.5f;
            }
        }
        private float _MaxSpeed;
        public float MaxSpeed{
            get { return this._MaxSpeed; }
            set { this._MaxSpeed = value; }
        }
        public void Run() {
            System.Console.WriteLine("Dog is running");
        }
        public void Walk()
        {
            System.Console.WriteLine("Dog is walking");
        }
        public void Fly()
        {
            System.Console.WriteLine("Dog can't fly");
        }

    }
    class Person : IMovable
    {
        public float Speed
        {
            get
            {
                return 20.5f;
            }
        }
        private float _MaxSpeed;
        public float MaxSpeed
        {
            get { return this._MaxSpeed; }
            set { this._MaxSpeed = value; }
        }
        public void Run()
        {
            System.Console.WriteLine("Person is running");
        }
        public void Walk()
        {
            System.Console.WriteLine("Person is walking");
        }
        public void Fly()
        {
            System.Console.WriteLine("Person flies with a plane");
        }

    }
    class Program
    {
        static void SthMove(IMovable mov) {
            string type = mov.GetType().Name;
            System.Console.WriteLine("This is a {0} ",type);
            System.Console.WriteLine("{0}.Speed={1}",type,mov.Speed);
            System.Console.WriteLine("{0}.MaxSpeed={1}", type, mov.MaxSpeed);
            mov.Walk();
            mov.Run();
            mov.Fly();
        }
        static void Main(string[] args)
        {
            Person aPerson = new Person();
            aPerson.MaxSpeed = 50;
            SthMove(aPerson);
            IMovable mov = new Dog();
            mov.MaxSpeed = 20;
            SthMove(mov);
            System.Console.ReadLine();
        }
    }
}

�l�果�Q?br /> This is a Person
Person.Speed=20.5
Person.MaxSpeed=50
Person is walking
Person is running
Person flies with a plane
This is a Dog
Dog.Speed=10.5
Dog.MaxSpeed=20
Dog is walking
Dog is running
Dog can't fly

一个类可以实现多个接口。如有两个接口IMovable�Q�ISpeakable�Q�定义一个Person�c�L��实现�q�两个接�?br /> class Person:IMovable,ISpeakable

期待明天 2009-10-26 18:21 发表评论

C#事�g

期待明天 — Mon, 26 Oct 2009 08:31:00 GMT

■事�Ӟ��事�g是一�U�函数回调机�Ӟ��它通过委托来实现函数回调�?br /> 使用事�g之前�Q�首先在需要上报的�c�M��声明一个事�Ӟ��通常包含两个步骤�Q?br /> (1)定义一个委托类型（EventHandler�Q�表�C�时间处理函数的�c�d��
(2)在类中用关键字event声明一个EventHandler�c�d��的事�Ӟ��事�g同样��h��讉K��性，通常为public

delegate void MyEventHandler(Object sender,EventArgs e)
class EventClass{
public event MyEventHandler MyEvent;
}
■注册和注销事�g
一个类的��用者需要处理类的事�Ӟ��通常需�?个步骤：
(1)��处理的事件增加处理函�?br /> (2)��事件处理函数通过+=�q�算�W�注册到要处理的事�g
(3)处理完成后，通过-=�q�算�W�注销不需要的事�g处理函数
�?br />

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace EventDelegate
{
    delegate void MyEventHandler(Object sender,EventArgs e);
    class EventClass {
        public event MyEventHandler MyEvent;
        protected void OnMyEvent(EventArgs e) {
            System.Console.WriteLine("EventClass:Ready to fire a MyEvent");
            if (this.MyEvent != null) {
                System.Console.WriteLine("EventClass:fire a MyEvent");
                this.MyEvent(this, e);
            }
        }
        public void FireEvent() {
            this.OnMyEvent(EventArgs.Empty);
        }
    }
    class Program
    {
        static void GetAEvent(object sender, EventArgs e) {
            System.Console.WriteLine("GetAEvent:Get a Event EventClass.MyEvent");
        }
        static void Main(string[] args)
        {
            EventClass eventClass = new EventClass();
            eventClass.MyEvent += new MyEventHandler(GetAEvent);
            eventClass.FireEvent();
            eventClass.MyEvent -= new MyEventHandler(GetAEvent);
            eventClass.FireEvent();
            System.Console.ReadLine();
        }
    }
}

�q�行�l�果�Q?br /> EventClass:Ready to fire a MyEvent
EventClass:fire a MyEvent
GetAEvent:Get a Event EventClass.MyEvent
EventClass:Ready to fire a MyEvent

期待明天 2009-10-26 16:31 发表评论

C#函数委托

期待明天 — Mon, 26 Oct 2009 07:59:00 GMT

委托是一�U�动态调用函数的方式�Q�通过委托可以��一些相同类型的函数串联��h��依次执行。委托是函数回调和事件机制的基础�?br /> 委托�Q�通过delegate关键字来声明�Q�通过new�Q?=,-=�q�算�W��ؓ其分配函数�?br /> delegate void StrParaFunc(int no,string str);//定义一个委托，没有�q�回��|��依次包含两个数据�c�d��为int和string的参�?br />

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace useDelegate
{
    class Program
    {
        ///

/// 定义委托
///

        ///
        ///
        delegate void StrParaFunc(int no, string str);

        static void PrintString(int no, string str) {
            System.Console.WriteLine("{0}:PrintString:{1}",no,str);
        }
        static void ShowString(int no, string str)
        {
            System.Console.WriteLine("{0}:ShowString:{1}", no, str);
        }
        static void Main(string[] args)
        {
            //通过new初始化委�?/span>
            System.Console.WriteLine("**********************");
            StrParaFunc spfHandler1 = new StrParaFunc(PrintString);
            System.Console.WriteLine("�W�一个委托对象，�?个引用函敎ͼ�");
            spfHandler1(1,"a string 1");//委托�c�d��中有一个引用函敎ͼ��l�果�?�?nbsp;
            System.Console.WriteLine("**********************");

            spfHandler1 += ShowString;//通过+=增加引用函数
            System.Console.WriteLine("�W�一个委托对象，增加了一个引用函敎ͼ��?个引用函敎ͼ�");
            spfHandler1(2,"a string 2");//委托中有两个引用函数�Q�结果有2�?nbsp;
            System.Console.WriteLine("**********************");

            spfHandler1 -= PrintString; //通过-=�U�除引用函数
            System.Console.WriteLine("�W�一个委托对象，减少了一个引用函敎ͼ��?个引用函敎ͼ�");
            spfHandler1(3, "a string 3"); //委托中有一个引用函敎ͼ��l�果1�?/span>
            System.Console.WriteLine("**********************");

            //通过函数地址直接初始化委�?/span>
            StrParaFunc spfHandler2 = PrintString;
            spfHandler2(4, "a string 4");
            System.Console.WriteLine("**********************");
            System.Console.ReadLine();
        }
    }
}

�q�行�l�果�Q?br />
**********************
�W�一个委托对象，�?个引用函敎ͼ�
1:PrintString:a string 1
**********************
�W�一个委托对象，增加了一个引用函敎ͼ��?个引用函敎ͼ�
2:PrintString:a string 2
2:ShowString:a string 2
**********************
�W�一个委托对象，减少了一个引用函敎ͼ��?个引用函敎ͼ�
3:ShowString:a string 3
**********************
4:PrintString:a string 4
**********************

期待明天 2009-10-26 15:59 发表评论

C# 函数覆盖

期待明天 — Mon, 26 Oct 2009 07:57:00 GMT

覆盖�c�L��员：通过new关键字修饰虚函数表示覆盖该虚函数�?br /> 一个虚函数被覆盖后�Q��Q何父�c�d��量都不能讉K��该虚函数的具体实现�?br /> public virtual void IntroduceMyself(){...}//父类虚函�?br /> public new void IntroduceMyself(){...}//子类覆盖父类虚函�?br />

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MethodOverrideByNew
{
    public enum Genders {
        Female=0,
        Male=1
    }
    public class Person {
        protected string _name;
        protected int _age;
        protected Genders _gender;
        ///

/// 父类构造函�?/span>
///

        public Person() {
            this._name = "DefaultName";
            this._age = 23;
            this._gender = Genders.Male;
        }
        ///

/// 定义虚函数IntroduceMyself()
///

        public virtual void IntroduceMyself() {
            System.Console.WriteLine("Person.IntroduceMyself()");
        }
        ///

/// 定义虚函数PrintName()
///

        public virtual void PrintName() {
            System.Console.WriteLine("Person.PrintName()");
        }
    }
    public class ChinesePerson :Person{
        ///

/// 子类构造函敎ͼ�指明从父�c�L��参构造函数调用�v
///

        public ChinesePerson() :base(){
            this._name = "DefaultChineseName";
        }
        ///

/// 覆盖父类�Ҏ��IntroduceMyself�Q��用new关键字修饰虚函数
///

        public new void IntroduceMyself() {
            System.Console.WriteLine("ChinesePerson.IntroduceMyself()");
        }
        ///

/// 重蝲父类�Ҏ��PrintName�Q��用override关键字修饰虚函数
///

        public override void PrintName(){
            System.Console.WriteLine("ChinesePerson.PrintName()");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            //定义两个对象�Q�一个父�c�d��象，一个子�c�d��?/span>
            Person aPerson = new ChinesePerson();
            ChinesePerson cnPerson = new ChinesePerson();
            //调用覆盖的方法，父类对象不能调用子类覆盖�q�的�Ҏ��Q�只能调用自�w�的虚函数方�?/span>
            aPerson.IntroduceMyself();
            cnPerson.IntroduceMyself();
            //调用重蝲�Ҏ��Q�父�c�d��象和子类对象都可以调用子�c�重载过后的�Ҏ��
            aPerson.PrintName();
            cnPerson.PrintName();

            System.Console.ReadLine();
        }
    }
}

�l�果�Q?br /> Person.IntroduceMyself()
ChinesePerson.IntroduceMyself()
ChinesePerson.PrintName()
ChinesePerson.PrintName()

期待明天 2009-10-26 15:57 发表评论

C# 函数重蝲

期待明天 — Mon, 26 Oct 2009 06:07:00 GMT

�Ҏ��重蝲�Q�在C#中通过虚函数来实现�Q�具体做法：现在父类中用virtual��其声明��函数�Q�然后在子类中用override关键字来指定该函��Cؓ重蝲函数。重载函数必��d��有父�c�d��C��的参��C��敎ͼ�参数�c�d��和返回类型�?br />

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MethodOverride
{
    public enum Genders {
        Female=0,
        Male=1
    }
    public class Person {
        protected string _name;
        protected int _age;
        protected Genders _gender;
        public Person() {
            this._name = "default name";
            this._age = 20;
            this._gender = Genders.Male;
        }
        public virtual void IntroduceMyself() {
            System.Console.WriteLine("introduce myself");
        }
    }

    public class ChinesePerson : Person {
        public ChinesePerson() : base() {
            this._name = "default Chinese Name";
        }
        public override void IntroduceMyself()
        {
            System.Console.WriteLine("我叫{0},�q�龄{1},性别{2}",this._name,this._age,this._gender);
        }
    }

    public class EnglishPerson : Person
    {
        public EnglishPerson(): base()
        {
            this._name = "default English Name";
        }
        public override void IntroduceMyself()
        {
            System.Console.WriteLine("My Name is{0},my age is {1},my gender is {2}", this._name, this._age, this._gender);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Person aPerson = new Person();
            aPerson.IntroduceMyself();
            aPerson = new ChinesePerson();
            aPerson.IntroduceMyself();
            aPerson = new EnglishPerson();
            aPerson.IntroduceMyself();
            System.Console.ReadLine();
        }
    }
}

�l�果如下�Q?br /> introduce myself
我叫default Chinese Name,�q�龄20,性别Male
My Name isdefault English Name,my age is 20,my gender is Male

期待明天 2009-10-26 14:07 发表评论

�l�承�Q�用冒号实现

期待明天 — Sun, 25 Oct 2009 15:33:00 GMT

■构造顺序：子类对象在创建时�Q�构造函数的调用��序是：首先调用父类构造函敎ͼ�再调用自��q��构造函数。默认情况下�Q�子�c�L��造函��C��调用的是父类不带参数的构造函数�?br /> ■base关键字与this关键字相��|��它表�C�当前类的直接父�c�d��象，需要明��用父�c�L��员时��p��使用base关键字�?br />

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Inherit
{
///

/// parent class
///

    class BaseClass {
        public BaseClass(int pubVal) {
            System.Console.WriteLine("BaseClass(int) created");
        }
        public BaseClass() {
            System.Console.WriteLine("BaseClass() created");
        }
    }
    ///

/// child class inherited from BaseClass
///

    class DevClass : BaseClass {
        public DevClass() {
            System.Console.WriteLine("DevClass() created");
        }
        public DevClass(int pubVal):base(pubVal)
        {
            System.Console.WriteLine("DevClass(int) created");
        }
    }
    ///

///class for testing result
///

    class Program
    {
        static void Main(string[] args)
        {
            DevClass devClass1 = new DevClass();
            DevClass devClass2 = new DevClass(12);
            System.Console.ReadLine();
        }
    }
}

�q�行�l�果�Q?br /> BaseClass() created
DevClass() created
BaseClass(int) created
DevClass(int) created

期待明天 2009-10-25 23:33 发表评论

期待明天 — Sun, 25 Oct 2009 15:13:00 GMT

静态成员通过点运��符来访问，但是不能通过对象讉K��Q�只能通过�c�d��讉K��?br /> 静态成员是属于�cȝ��Q�所以不要在静态字�D�中讉K��属于某个对象的具体数据�?br /> static public int a;//定义一个静态变量a�Q�注意修饰符的顺序可以换�Q�static public 可以换成public static�Q?br />

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace StaticMemberTest
{
    class Program
    {
        static public int a = 10;
        static void Main(string[] args)
        {
            System.Console.WriteLine("{0}",a);
            addStatic(456);
            System.Console.WriteLine("{0}", a);
            System.Console.ReadLine();
        }
       static void addStatic(int b){
            Program.a=Program.a+b;
        }
    }
}
�l�果�Q?br /> 10
466

期待明天 2009-10-25 23:13 发表评论

期待明天 — Sun, 25 Oct 2009 14:51:00 GMT

索引器提供了一�U�可以让�c�被当作数组�q�行讉K��的方式。在C#中，�cȝ��引器是通过this的属性实现的�?br /> index.ToString("D2")��index转换成一个具有两个字�W�宽度的字符�?br />
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ClassIndexer
{
///

/// define a class called AClass,which has only one private variable
///

   class AClass {
       private string _name;
       public string Name {
           get { return this._name; }
           set { this._name = value; }
       }
       public AClass(string name) {
           this._name = name;
       }
    }
    ///

/// AClassContainer class
///

   class AClassContainer {
       private AClass[] _AClassList;
       public AClassContainer() {
           this._AClassList = new AClass[10];
       }
       public AClassContainer(int cap) {
           this._AClassList = new AClass[cap];
       }
       ///

/// class indexer by using int
///

       ///
       ///
       public AClass this[int index] {
           get {
               if ((index < 0) || (index > this._AClassList.Length)) return null;
               else return this._AClassList[index];
           }
           set {
               if ((index < 0) || (index > this._AClassList.Length)) return;
               else this._AClassList[index] = value;
           }
       }
       ///

/// class indexer by using string
///

       ///
       ///
       public AClass this[string name] {
           get {
               foreach (AClass cls in this._AClassList) {
                   if (cls.Name == name) return cls;
               }
               return null;
           }
       }
   }
    class Program
    {
        static void Main(string[] args)
        {
            int count = 10;
            AClassContainer classContainer = new AClassContainer(count);
            for (int index = 0; index < count; index++) {
                string name = index.ToString("D2");
                classContainer[index] = new AClass(name);
            }
            for (int index = 0; index < count; index++)
            {
                AClass cls = classContainer[index];
                System.Console.WriteLine("classContainer[{0}].Name=\"{1}\"",index,cls.Name);
            }
            System.Console.WriteLine();
            for (int index = count - 1; index >= 0; index--) {
                string name = index.ToString("D2");
                AClass cls = classContainer[name];
                System.Console.WriteLine("classContainer[{0}].Name=\"{1}\"",name,cls.Name);
            }
            System.Console.ReadLine();
        }
    }
}

�l�果�Q?br /> classContainer[0].Name="00"
classContainer[1].Name="01"
classContainer[2].Name="02"
classContainer[3].Name="03"
classContainer[4].Name="04"
classContainer[5].Name="05"
classContainer[6].Name="06"
classContainer[7].Name="07"
classContainer[8].Name="08"
classContainer[9].Name="09"

classContainer[09].Name="09"
classContainer[08].Name="08"
classContainer[07].Name="07"
classContainer[06].Name="06"
classContainer[05].Name="05"
classContainer[04].Name="04"
classContainer[03].Name="03"
classContainer[02].Name="02"
classContainer[01].Name="01"
classContainer[00].Name="00"

期待明天 2009-10-25 22:51 发表评论

C# �c�d��性的讉K��器，get与set传统做法�Q�同java

期待明天 — Sun, 25 Oct 2009 10:52:00 GMT

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace useClass
{
///

/// define Genders ,type is enum
///

    public enum Genders {
        Female=0,
        Male=1
    }
    public class Person {
       private  string name;
       private int age;
       private Genders gender;
        ///

/// default class constructor without any parameters
///

public Person() { }
///

/// class constructor with all fields
///

        ///
        ///
        ///
       public Person(string name, int age, Genders gender) {
           this.name = name;
           this.age = age;
           this.gender = gender;
       }
        ///

/// getters
///

        ///
       public string getName() {
           return this.name;
       }
       public int getAge() {
           return this.age;
       }
       public Genders getGender() {
           return this.gender;
       }
        ///

/// setters
///

        ///
       public void setName(string name) {
           this.name = name;
       }
       public void setAge(int age) {
           this.age = age;
       }
       public void setGender(Genders gender) {
           this.gender = gender;
       }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Person aPerson = new Person();
            aPerson.setName("rorely");
            aPerson.setAge(19);
            aPerson.setGender(0);
            System.Console.WriteLine("{0},{1},{2}",aPerson.getName(),aPerson.getAge(),aPerson.getGender());

            Person bPerson = new Person("Rose",23,Genders.Female);
            System.Console.WriteLine("{0},{1},{2}", bPerson.getName(), bPerson.getAge(), bPerson.getGender());

            System.Console.ReadLine();
        }
    }
}

�l�果�Q?br /> rorely,19,Female
Rose,23,Female

期待明天 2009-10-25 18:52 发表评论

期待明天 — Sun, 25 Oct 2009 10:50:00 GMT

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace useClass2
{
    public enum Genders { Female=0,Male=1}
    public class Person {
        ///

/// _name is private field,Name is public attribute�Q�姓名前后的�I�去除掉
///

        private string _name;
        public string Name {
            get { return this._name; }
            set { this._name = value.Trim(); }
        }
        ///

/// _age:1-120之间�Q�超��个范��_��默认讄��?0
///

        private int _age;
        public int Age {
            get { return this._age; }
            set {
                if ((value > 120) || (value < 1)) this._age = 20;
                else this._age = value;
            }
        }
        ///

/// _gender
///

        private Genders _gender;
        public Genders Gender {
            get { return this._gender; }
            set { this._gender = value; }
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Person aPerson = new Person();
            aPerson.Name = "Rorely";
            aPerson.Age = 19;
            aPerson.Gender = Genders.Female;
            PrintPerson(aPerson);
            System.Console.ReadLine();
        }
        static void PrintPerson(Person a) {
            System.Console.WriteLine("{0},{1},{2}",a.Name,a.Age,a.Gender);
        }
    }
}

�l�果�Q?br /> rorely,19,Female

期待明天 2009-10-25 18:50 发表评论

��g��递和引用传递，函数定义

期待明天 — Sun, 25 Oct 2009 08:58:00 GMT

��g��递，引用传�?br /> ��g��递：是对所引用参数�q�行一�ơ副本拷贝，对参数的修改只是对副本的修改�Q�函数调用结束，副本丢弃�Q�原来的变量不变
引用传递：参数被传递到函数�Ӟ��不复制副本，而是直接��参数自�w�传入到函数�Q�函数内对参数的��M��改变都将反映到参��C��?br /> 使用ref修饰�W�表明该参数是通过引用传递的�?br /> TransPara(a,ref b)//a为��g��递，b为引用传�?br />
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ParametersRefAndValue
{
    class Program
    {
        static void Main(string[] args)
        {
            int val = 23, refVal = 56;
            //输出调用前的参数�?/span>
            System.Console.WriteLine("Before call TransPara: val={0},refVal={1}",val,refVal);
            TransPara(val,ref refVal);//调用函数�Q��ƈ且输��用中的参数�?br />             //输出调用后的参数�?/span>
            System.Console.WriteLine("After call TransPara: val={0},refVal={1}", val, refVal);
            System.Console.ReadLine();
        }
        static void TransPara(int val, ref int refVal) {
            val++;
            refVal--;
            System.Console.WriteLine("During call  TransPara: val={0},refVal={0}", val,refVal);
        }
    }
}

�l�果如下�Q?br />
Before call TransPara: val=23,refVal=56
During call TransPara: val=24,refVal=24
After call TransPara: val=23,refVal=55

期待明天 2009-10-25 16:58 发表评论

foreach遍历数组元素

期待明天 — Sun, 25 Oct 2009 08:22:00 GMT

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ArrayOperation
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] a = { 123,12,245,1,2,45,67};//一�l�数�l�，�c�d��为int
            int[,] b = { {12,34,1,7},{23,345,12,45}};//二维数组�Q�类型�ؓint
            string[] c = { "hello","World","你好"};//一�l�数�l�，�c�d��为string
            foreach (int i in a) {//输出a数组
                System.Console.Write("{0}  ",i);
            }
            System.Console.WriteLine();//换行
            foreach (int j in b){//输出b数组
                System.Console.Write("{0}  ", j);
            }
            System.Console.WriteLine();//换行
            foreach (string j in c){//输出c数组
                System.Console.Write("{0}  ", j);
            }
            System.Console.ReadLine();//方便看结果，免得�l�果一闪而过
        }
    }
}

期待明天 2009-10-25 16:22 发表评论

期待明天 — Sun, 25 Oct 2009 08:01:00 GMT

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace TypeMaxMinValue
{
    class Program
    {
        static void Main(string[] args)
        {
            PrintDataRange();
        }
        static void PrintDataRange() {
            System.Console.WriteLine("int�c�d��的最大�?  {0},最��?  {1}", int.MaxValue, int.MinValue);
            System.Console.WriteLine("uint�c�d��的最大�?  {0},最��?  {1}", uint.MaxValue, uint.MinValue);
            System.Console.WriteLine("byte�c�d��的最大�?  {0},最��?  {1}", byte.MaxValue, byte.MinValue);
            System.Console.WriteLine("sbyte�c�d��的最大�?  {0},最��?  {1}", sbyte.MaxValue, sbyte.MinValue);
            System.Console.WriteLine("short�c�d��的最大�?  {0},最��?  {1}", short.MaxValue, short.MinValue);
            System.Console.WriteLine("ushort�c�d��的最大�?  {0},最��?  {1}",ushort.MaxValue, ushort.MinValue);
            System.Console.WriteLine("long�c�d��的最大�?  {0},最��?  {1}", long.MaxValue, long.MinValue);
            System.Console.WriteLine("ulong�c�d��的最大�?  {0},最��?  {1}", ulong.MaxValue, ulong.MinValue);
            System.Console.WriteLine("float�c�d��的最大�?  {0},最��?  {1}", float.MaxValue, float.MinValue);
            System.Console.WriteLine("double�c�d��的最大�?  {0},最��?  {1}", double.MaxValue, double.MinValue);
            System.Console.WriteLine("decimal�c�d��的最大�?  {0},最��?  {1}", decimal.MaxValue, decimal.MinValue);
            System.Console.ReadLine();
        }
    }
}

�q�行�l�果如下�Q?br />

int�c�d��的最大�? 2147483647,最��? -2147483648
uint�c�d��的最大�? 4294967295,最��? 0
byte�c�d��的最大�? 255,最��? 0
sbyte�c�d��的最大�? 127,最��? -128
short�c�d��的最大�? 32767,最��? -32768
ushort�c�d��的最大�? 65535,最��? 0
long�c�d��的最大�? 9223372036854775807,最��? -9223372036854775808
ulong�c�d��的最大�? 18446744073709551615,最��? 0
float�c�d��的最大�? 3.402823E+38,最��? -3.402823E+38
double�c�d��的最大�? 1.79769313486232E+308,最��? -1.79769313486232E+308
decimal�c�d��的最大�? 79228162514264337593543950335,最��? -792281625142643375 93543950335

期待明天 2009-10-25 16:01 发表评论

�E�序�l�构--the beginning of learning CSharp

期待明天 — Sun, 25 Oct 2009 06:46:00 GMT

属性文件夹Properties
引用文�g夹：提供��目中引用到的命名空��_��Ҏ��不同的应用程序类型会有不同的默认命名�I�间�Q�如System,System.Data,System.Xml
Program.cs�Q�项目的启动代码�Q�在该文件中定义��目的启动入口，即Main函数

期待明天 2009-10-25 14:46 发表评论

HelloWorld.cs

期待明天 — Mon, 28 Sep 2009 13:46:00 GMT

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace HelloWorld
{
    class Program
    {
        static void Main(string[] args)
        {
            for (int i = 0; i < 3;i++ )
                System.Console.WriteLine("{0}:Hello World!",i);
            System.Console.ReadLine();//��Z��便于查看上面打印三个HelloWorld的结�?br />         }
    }
}

说明�Q�该�E�序为：Windows Console Application
打印三个hello World

Main函数是该��目的启动入口�?br /> 在控制台应用�E�序中默认引用包括：System,System.Data,System.Xml

�q�行�l�果如下�Q?br />
0:Hello World!
1:Hello World!
2:Hello World!

期待明天 2009-09-28 21:46 发表评论