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. 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