C# Programming Study #1

  • 引用的时候需要在参数和使用的时候加上 ref 关键字
  •         static bool addnum (ref int val)    //引用
        {
            ++val;
            return true;
        }

     

  • 参数数组的概念，可以接受该类型的数组，不限制大小，关键字 params

  •         static int getlength (params int[] vals)    //参数数组
        {
            int sum = 0;
            foreach (int val in vals)
            {
                sum += val;
            }
            return sum;
        }

     

  • 输出参数的概念，类似参数数组，不过声明的时候可以不初始化

  •         static int MaxValue (int[] intArray, out int maxIndex)  //输出参数
        {
            int maxValue = intArray[0];
            maxIndex = 0;
            for (int i = 1; i < intArray.Length; ++i)
            {
                if (intArray[i] > maxValue)
                {
                    maxValue = intArray[i];
                    maxIndex = i;
                }
            }
            return maxValue;
        }
  • 委托 delegate : 委托的声明类似函数，但不带函数体，并且要使用 delegate 关键字。委托的声明指定了一个 返回类型 和一个 参数列表
  •         delegate double ProcessDelegate (double param1, double param2);

        static double Multiply (double param1, double param2)
        {
            return param1 * param2;
        }

        static double Divide (double param1, double param2)
        {
            return param1 / param2;
        }

        static void Main(string[] args)
        {
            ProcessDelegate process;
            string input = Console.ReadLine();
            if (input.CompareTo("M") == 0)
            {
                process = new ProcessDelegate (Multiply);
            }
            else
            {
                process = new ProcessDelegate(Divide);
            }
            double param1 = 3.123;
            double param2 = 23.12;
            Console.WriteLine("{0}", process(param1, param2));
        }
  • 指定类是抽象的 abstract，不能实例化，只能继承，可以有抽象成员
  •     abstract class MyClass1
    {

    }

     

  • 指定类是密封的 sealed， 不能继承
  •     sealed class MyClass2
    {

    }

     

  • 成员定义
    1. public　　   成员可以由任何代码访问
    2. private       成员由类中的代码访问
    3. internal　　成员只能由定义它的程序集内部的代码访问
    4. protected   成员只能由类或派生类中的代码访问
  • 定义方法
    1. virtual     方法可以重写
    2. abstract   方法必须在非抽象类的派生类中重写
    3. override   方法重写了一个基类方法
    4. extern      方法定义放在其他地方
  • 接口实现
    • 不允许使用访问修饰符(public, private, protected, internal)
    • 接口成员不能包含代码体
    • 接口不能定义字段成员
    • 接口成员不能使用关键字 static, virtual, abstractm sealed
    • 类型定义成员是禁止的
    •     public interface IMyInterface //在类中实现接口
    {
        void DoSomething();
        void DoSomethingElse();
    }

    public class MyClass : IMyInterface
    {
        public void DoSomething()
        {

        }
        public void DosomethingElse()
        {

        }
    }

       

  • 泛型
    • 可空类型
      • 　　int? 是 System.Nullble <int>的缩
      •             int? op = 5;
            int? result1 = (int)op * 2;　　//method 1
            int? result2 = op.Value * 2;  //method 2

            int? op1 = null;
            int? op2 = 5;
            int? result3 = op1 * op2;

         

    • ?? 运算符 
      • op1 ?? op2
op1 == null ? op2 : op1


         

  • 泛型类 List
    • 　　 
          class Program
    {
        static void Main(string[] args)
        {
            List<Animal> animalCollection = new List<Animal>();
            animalCollection.Add(new Cow("Tom"));
            animalCollection.Add(new Dog("Dave"));

            foreach (Animal myAnimal in animalCollection)
            {
                Console.WriteLine(myAnimal.GetName());
            }
        }
    }

       

  • 属性的访问器
  • 包含与获取（读取或计算）或设置（写）属性有关的可执行语句。访问器声明可以包含 get 访问器或 set 访问器，或者两者均包含。
    • get {}
      • get 访问器体与方法体相似。它必须返回属性类型的值。执行 get 访问器相当于读取字段的值。以下是返回私有字段 name 的值的 get 访问器：
      • 　　 
        private string name;   // the name field
public string Name   // the Name property
{
    get 
    {
       return name; 
    }
 }

         

      • 当引用属性时，除非该属性为赋值目标，否则将调用 get 访问器读取该属性的值。例如：

        Employee e1 = new Employee(); ... Console.Write(e1.Name);  

      • // The get accessor is invoked here get 访问器必须在 return 或 throw 语句中终止，并且控制不能超出访问器体。

    • set {}
      • set 访问器与返回 void 的方法类似。它使用称为 value 的隐式参数，此参数的类型是属性的类型。在下例中，set 访问器被添加到 Name 属性：
      • public string Name 
 {
    get 
    { 
       return name; 
    }
    set 
    {
       name = value; 
    }
 }

         

      • 当对属性赋值时，用提供新值的参数调用 set 访问器。例如：

        e1.Name = "Joe"; 

      •   // The set accessor is invoked here 在 set 访问器中对局部变量声明使用隐式参数名 (value) 是错误的。

    • // property_hiding.cs
// Property hiding
using System;
public class BaseClass 
 {
    private string name;
    public string Name
    {
       get 
       {
          return name; 
       }
       set 
       {
          name = value; 
       }
    }
 }

public class DerivedClass : BaseClass 
 {
    private string name;
    public new string Name   // Notice the use of the new modifier
   {
       get 
       {
          return name; 
       }
       set 
       {
          name = value; 
       }
    }
 }

public class MainClass 
 {
    public static void Main() 
    {
       DerivedClass d1 = new DerivedClass();
       d1.Name = "John"; // Derived class property
      Console.WriteLine("Name in the derived class is: {0}",d1.Name);
       ((BaseClass)d1).Name = "Mary"; // Base class property
      Console.WriteLine("Name in the base class is: {0}",
          ((BaseClass)d1).Name);   
    }
 }
      Example Code

       

  • #region  DisaplayName
  • #endregion
    • 用来注释中间代码 的作用 而且在其他地方用到中间的类和方法 都会有你标注的注释
    • 本身不参与编译 还可以缩进代码 方便阅览折叠代码
      • 　　 
          //   preprocessor_region.cs  
  #region   MyClass   definition  
  public   class   MyClass    
  {  
        public   static   void   Main()    
        {  
        }  
  }  
  #endregion

         

posted @ 2015-07-09 11:00  Jeremy Wu  阅读(191)  评论(0)  编辑  收藏  举报