C#-杂记(临时)

 

Form 启动,首先有一个Load事件.
Convert.ToInt16
使用  #endregion 可合并当中代码 #region #endregion 可合并当中代码
委托就相当于函数指针

如何访问Resource.resx中自定义的资源?
答:WindowsApplication2.Properties.Resources.test_str
注:namespace WindowsApplication2
    test_str 是用户手动定义

Console.WriteLine("Hello World!");//自动生成一个回车
Console.Write("Hello World!");//没有回车
Console.WriteLine("The result is {0} or {1}",10,20);
/**//*输出:The result is 10 or 20,如果后面还有30的话,前面再依次加
上{3},类推...*/

foreach用法
    int[] array = new int[]...{1,2,3};            
    foreach (int i in array)
    ...{
       Console.WriteLine(i);//强烈注意这里的"i"
    }

结构属性

  class  myProgram
     ... {
        static void Main(string[] args)
        ...{
            SimpleStruct ss = new SimpleStruct();
            ss.X = 5;           
            ss.DisplayX();
        }
    }

     struct  SimpleStruct
     ... {
        private int xval;
        //属性用法(X相当于一个集成了get/set两个方法的函数)
        public int X 
        ...{
            get
            ...{
                return xval;
            }
            set
            ...{
                if (value < 100)
                    xval = value;
            }
        }
        public void DisplayX()
        ...{
            Console.WriteLine("The stored value is: {0}", xval);
        }
    }

 

 

接口

interface  CommInterface
... {
    void CommMethod();
}

class  myClass : CommInterface
... {
    void CommInterface.CommMethod()
    ...{
        Console.WriteLine("接口方法已实现!");
    }

    static void Main() //妈的,这个Main第一个字母要大写
    ...{
        CommInterface obj = new myClass();
        obj.CommMethod();
    }
}

/**/ /*C#中类的继承方式只能单继承,但可以继承一个以上的接口*/

 

 

object

class  ObjectClass
... {
    public int i = 100;
}

class  myClass
... {
    static void Main()
    ...{
        object a;
        a = 10;
        Console.WriteLine(a.GetType());
        Console.WriteLine(a.ToString());

        a = new ObjectClass(); //注意
        ObjectClass obj = (ObjectClass)a; //注意
        obj.i = 1000;
        Console.WriteLine(obj.i.ToString());
    }
}

    在 C# 的统一类型系统中，所有类型（预定义类型、用户定义类型、引用类型和值类型）都是直接或间接从 Object 继承的。可以将任何类型的值赋给  object  类型的变量。将值类型的变量转换为对象的过程称为 " 装箱 " 。将对象类型的变量转换为值类型的过程称为 " 取消装箱 " 。

 

 

abstract

abstract   class  ShapesClass
... {
    abstract public int Area();
}
class  Square : ShapesClass
... {
    int x, y;    
    public override int Area()
    ...{
        return x * y;
    }
}

抽象类具有以下特性：
※抽象类不能实例化。
※抽象类可以包含抽象方法和抽象访问器。
※不能用  sealed （C# 参考）修饰符修改抽象类，这意味着抽象类不能被继承。
※从抽象类派生的非抽象类必须包括继承的所有抽象方法和抽象访问器的实实现。
※在方法或属性声明中使用  abstract  修饰符以指示方法或属性不包含实现。

抽象方法具有以下特性：
※抽象方法是隐式的虚方法。
※只允许在抽象类中使用抽象方法声明。
※因为抽象方法声明不提供实际的实现，所以没有方法体；方法声明只是以一个分号结束，并且在签名后没有大括号 ( ... { } )。例如：
public   abstract   void  MyMethod();

 

// 数组
             // int[,] Iarr = new int[,] { { 1, 2, 3 }, { 4, 5, 6 } };     // 数组的定义方式有别于C++
             // Console.WriteLine("the value is {0}", Iarr[0, 1]);     // 数组的使用方式有别于C++    

             // int[][] Iarr = new int[2][] { new int[] { 1, 2, 3 }, new int[] { 4,5,6 } };
             // int[,] Iarr1 = new int[,] { { 1,2,3}, {4,5,6 } };  // 交错数组

             // 装箱
             // int a = 10;
             // object b = a;
             // Console.WriteLine(b);

             // 拆箱
             // object a = 10;
             // int b = (int)a;
             // Console.WriteLine(b);

             /**/ /***************************************************************
             * 类的修饰符:
             * private: 只有对.NET中的应用程序或库才能访问;
             * internal: 只有其所在类才能访问;
             * sealed: 密封类,不允许被继承.
             * 
             * 类中成员的修饰符
             * private、protected、public 基本等同于C++;
             * internal: 对于统一包中的应用程序或库是透明的,但在包.NET之外是禁止访问的.
             * 
             * 命名空间:
             *        简单的说,一个命名空间不过是一组相互联系的类.正是把关联的类放在同一
             * 容器内才能把这些类同其它同名的类区分开来.命名空间是一种逻辑上的分组.
             * 
             * 命名空间的声明:
             * 例1:                                    例2:
             * namespace N1                   namespace N1.N2
             * {                                        {
             *     namespace N2                     class A{}
             *     {                                    }
             *         class A{}
             *     }
             * }
             *                     例1与例2完全相同
             * 
             * using指示符:
             *        可以引进在其它命名空间中定义的命名 空间 和 类型,但它并不是提供了新
             * 的成员.
             * 例:
             * namespace N1.N2
             * {
             *     class A {}
             * }
             * namespace N3
             * {
             *     using A = N1.N2.A; //A是类N1.N2.A的别名
             *     class B:A {} //N3.B从类N1.N2.A中派生
             * }
             * 
             * 接口:
             *         接口中的成员不能是常量、域、操作符、构造函数或析构函数;
             *         接口默认访问方式是public,前面不能加任何修饰符;
             * 
             *         
             * 属性:
             *         get / set
             * 
             * */