BlogJava-有时天晴有时雨-随笔分类-CSharp

C# 匿名类的定义

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

■匿名类:匿名类用来表示临时使用的只读数据，所以必须在创建时初始化各字段的数据，并且只能读取这些字段的值，而不能设置这些字段的值
如：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)
        {
            //定义匿名类
            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();

        }
    }
}

结果：
first variable is: HelloWorld; theSecondVariable is:200
val.ToString() is:{ StrVal = HelloWorld, IntVal = 200 }

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

异常类Exception

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

■Exception类的主要成员：
Exception:构造函数，构造一个异常类，制定其异常消息，发生位置
Message：只读属性，获取当前异常提供的消息，该消息在构造异常时指定
Source：读写属性，获取和设置引起该异常的应用程序或对象的名称
TargetSite：只读属性，获取引发该异常的方法
ToString：公开方法，创建该异常的字符串表示形式，包括异常发生的位置，名称等信息

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);
        }
    }
}

结果：
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

■异常与错误
异常是可预见，可接受的，程序通过对异常的捕获和处理可以将异常带来的影响减小到最小；
错误是程序代码的错误，设计漏洞，是不可预见的，会给软件带来致命的影响
■捕获异常：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];
        }
    }
}

结果：

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，只是定义一系列的行为类型，不提供任何实现
interface IMovable{
   float speed{get;}
   float maxSpeed{get;set;}
   void Run()；
   void Walk();
   void Fly();
}
■接口的实现，通过冒号来实现

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();
        }
    }
}

结果：
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，ISpeakable，定义一个Person类来实现这两个接口
class Person:IMovable,ISpeakable

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

C#事件

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

■事件：事件是一种函数回调机制，它通过委托来实现函数回调。
使用事件之前，首先在需要上报的类中声明一个事件，通常包含两个步骤：
(1)定义一个委托类型（EventHandler）表示时间处理函数的类型
(2)在类中用关键字event声明一个EventHandler类型的事件，事件同样具有访问性，通常为public

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

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();
        }
    }
}

运行结果：
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

委托是一种动态调用函数的方式，通过委托可以将一些相同类型的函数串联起来依次执行。委托是函数回调和事件机制的基础。
委托，通过delegate关键字来声明，通过new，+=,-=运算符为其分配函数。
delegate void StrParaFunc(int no,string str);//定义一个委托，没有返回值，依次包含两个数据类型为int和string的参数

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初始化委托
            System.Console.WriteLine("**********************");
            StrParaFunc spfHandler1 = new StrParaFunc(PrintString);
            System.Console.WriteLine("第一个委托对象，有1个引用函数：");
            spfHandler1(1,"a string 1");//委托类型中有一个引用函数，结果有1个
            System.Console.WriteLine("**********************");

            spfHandler1 += ShowString;//通过+=增加引用函数
            System.Console.WriteLine("第一个委托对象，增加了一个引用函数，共2个引用函数：");
            spfHandler1(2,"a string 2");//委托中有两个引用函数，结果有2个
            System.Console.WriteLine("**********************");

            spfHandler1 -= PrintString; //通过-=移除引用函数
            System.Console.WriteLine("第一个委托对象，减少了一个引用函数，剩1个引用函数：");
            spfHandler1(3, "a string 3"); //委托中有一个引用函数，结果1个
            System.Console.WriteLine("**********************");

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

运行结果：

**********************
第一个委托对象，有1个引用函数：
1:PrintString:a string 1
**********************
第一个委托对象，增加了一个引用函数，共2个引用函数：
2:PrintString:a string 2
2:ShowString:a string 2
**********************
第一个委托对象，减少了一个引用函数，剩1个引用函数：
3:ShowString:a string 3
**********************
4:PrintString:a string 4
**********************

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

C# 函数覆盖

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

覆盖类成员：通过new关键字修饰虚函数表示覆盖该虚函数。
一个虚函数被覆盖后，任何父类变量都不能访问该虚函数的具体实现。
public virtual void IntroduceMyself(){...}//父类虚函数
public new void IntroduceMyself(){...}//子类覆盖父类虚函数

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;
        ///

/// 父类构造函数
///

        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{
        ///

/// 子类构造函数，指明从父类无参构造函数调用起
///

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

/// 覆盖父类方法IntroduceMyself，使用new关键字修饰虚函数
///

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

/// 重载父类方法PrintName，使用override关键字修饰虚函数
///

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

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

            System.Console.ReadLine();
        }
    }
}

结果：
Person.IntroduceMyself()
ChinesePerson.IntroduceMyself()
ChinesePerson.PrintName()
ChinesePerson.PrintName()

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

C# 函数重载

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

方法重载，在C#中通过虚函数来实现，具体做法：现在父类中用virtual将其声明为虚函数，然后在子类中用override关键字来指定该函数为重载函数。重载函数必须具有父类函数中的参数个数，参数类型和返回类型。

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},年龄{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();
        }
    }
}

结果如下：
introduce myself
我叫default Chinese Name,年龄20,性别Male
My Name isdefault English Name,my age is 20,my gender is Male

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

继承，用冒号实现

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

■构造顺序：子类对象在创建时，构造函数的调用顺序是：首先调用父类构造函数，再调用自己的构造函数。默认情况下，子类构造函数中调用的是父类不带参数的构造函数。
■base关键字与this关键字相似，它表示当前类的直接父类对象，需要明确使用父类成员时就要使用base关键字。

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();
        }
    }
}

运行结果：
BaseClass() created
DevClass() created
BaseClass(int) created
DevClass(int) created

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

静态成员

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

静态成员通过点运算符来访问，但是不能通过对象访问，只能通过类名访问。
静态成员是属于类的，所以不要在静态字段中访问属于某个对象的具体数据。
static public int a;//定义一个静态变量a（注意修饰符的顺序可以换，static public 可以换成public static）

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;
        }
    }
}
结果：
10
466

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

C#类索引器的使用

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

索引器提供了一种可以让类被当作数组进行访问的方式。在C#中，类索引器是通过this的属性实现的。
index.ToString("D2")将index转换成一个具有两个字符宽度的字符串

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();
        }
    }
}

结果：
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# 类属性的访问器，get与set传统做法，同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();
        }
    }
}

结果：
rorely,19,Female
Rose,23,Female

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

C# 类属性的访问器，get与set的定义

期待明天 — 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，姓名前后的空去除掉
///

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

/// _age:1-120之间，超出这个范围，默认设置为20
///

        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);
        }
    }
}

结果：
rorely,19,Female

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

值传递和引用传递，函数定义

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

值传递，引用传递
值传递：是对所引用参数进行一次副本拷贝，对参数的修改只是对副本的修改，函数调用结束，副本丢弃，原来的变量不变
引用传递：参数被传递到函数时，不复制副本，而是直接将参数自身传入到函数，函数内对参数的任何改变都将反映到参数上。
使用ref修饰符表明该参数是通过引用传递的。
TransPara(a,ref b)//a为值传递，b为引用传递

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;
            //输出调用前的参数值
            System.Console.WriteLine("Before call TransPara: val={0},refVal={1}",val,refVal);
            TransPara(val,ref refVal);//调用函数，并且输出调用中的参数值
            //输出调用后的参数值
            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);
        }
    }
}

结果如下：

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};//一维数组，类型为int
            int[,] b = { {12,34,1,7},{23,345,12,45}};//二维数组，类型为int
            string[] c = { "hello","World","你好"};//一维数组，类型为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();//方便看结果，免得结果一闪而过
        }
    }
}

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

C# 各种数据类型的最大值和最小值常数

期待明天 — 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类型的最大值:  {0},最小值:  {1}", int.MaxValue, int.MinValue);
            System.Console.WriteLine("uint类型的最大值:  {0},最小值:  {1}", uint.MaxValue, uint.MinValue);
            System.Console.WriteLine("byte类型的最大值:  {0},最小值:  {1}", byte.MaxValue, byte.MinValue);
            System.Console.WriteLine("sbyte类型的最大值:  {0},最小值:  {1}", sbyte.MaxValue, sbyte.MinValue);
            System.Console.WriteLine("short类型的最大值:  {0},最小值:  {1}", short.MaxValue, short.MinValue);
            System.Console.WriteLine("ushort类型的最大值:  {0},最小值:  {1}",ushort.MaxValue, ushort.MinValue);
            System.Console.WriteLine("long类型的最大值:  {0},最小值:  {1}", long.MaxValue, long.MinValue);
            System.Console.WriteLine("ulong类型的最大值:  {0},最小值:  {1}", ulong.MaxValue, ulong.MinValue);
            System.Console.WriteLine("float类型的最大值:  {0},最小值:  {1}", float.MaxValue, float.MinValue);
            System.Console.WriteLine("double类型的最大值:  {0},最小值:  {1}", double.MaxValue, double.MinValue);
            System.Console.WriteLine("decimal类型的最大值:  {0},最小值:  {1}", decimal.MaxValue, decimal.MinValue);
            System.Console.ReadLine();
        }
    }
}

运行结果如下：

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

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

程序结构--the beginning of learning CSharp

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

属性文件夹Properties
引用文件夹：提供项目中引用到的命名空间，根据不同的应用程序类型会有不同的默认命名空间，如System,System.Data,System.Xml
Program.cs：项目的启动代码，在该文件中定义项目的启动入口，即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();//为了便于查看上面打印三个HelloWorld的结果
        }
    }
}

说明：该程序为：Windows Console Application
打印三个hello World

Main函数是该项目的启动入口。
在控制台应用程序中默认引用包括：System,System.Data,System.Xml

运行结果如下：

0:Hello World!
1:Hello World!
2:Hello World!

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