Java による C# の攻撃 - 構文の知識ポイントの改善

1. クラスの初期化メソッド。クラスの初期化時に属性値を初期化する機能が追加されます。以下のコード。

前:

  Person person = new Child();
  person.Name = "Aomi";
  person.Move();

新:

 Person person = new Child()
 {
    Sex = "男",
    Name = "Aomi"
 };
 person.Move();

2. コレクションクラスの初期化メソッド。コレクション クラスの初期化は、以前のように単調な方法ではなくなりました。初期化中にいくつかの値を一緒に追加できます。

前:

List<string> strList = new List<string>();
strList.Add("a");
strList.Add("b");
strList.Add("c");

新しい

List<string> strList = new List<string>() { "a", "b", "c" };

キーワードvarの紹介

前の章でよく使用した型はすべて強い型です。 Javascript言語を使ったことがある人なら、弱い型付けと強い型付けについて理解できると思います。簡単に言うと、弱い型付けとは、型が定義されるときにその型を判断するのが難しいことを意味します。走って初めてそれがどのタイプであるかがわかります。 C# は厳密に型指定された言語であるため、コンパイル時にどのようなデータ型が定義されているかを知っておく必要があります。ただし、C# ではこの点で混乱します。なぜこのように言うのですか？次のコードを見てください。

var local = 1;

このコードは定義です...よし。作者も何と言っていいのか分からない。このような関連情報があります。彼にタイプがないわけではない。 var 型でもありません。ただし、それがどの型であるかはコンパイル時に決定されます。上記のコードがコンパイルされると、int 型であると判断されます。下の図

に示すように、上の図にプロンプ​​トが表示されます。ローカル変数 int local です。 int型であることが明確にわかります。開発プロセス中、作成者は変数を宣言するために var キーワードを使用する必要性に遭遇したことがありません。したがって、作者は心の中で一度も理解していませんでした-これをいつ使用する必要がありますか？ここで注意すべき構文が少しあります。 C# は厳密に型指定された言語であると先ほど述べました。したがって、var キーワードを定義するときは、初期化された値を指定する必要があります。

var キーワードの導入により、クラス宣言を記述する方法が登場しました。多くの本では、それらを匿名タイプと呼んでいます。次のコード

var student = new 
 { 
    Name="aomi",
    SNO="s0001"};

キーワード Dynamic の導入

著者は、C# が強く型付けされた言語であると上で述べました。キーワード var の導入は非常に理解しにくいです。作者が弱い型だと言っているのであれば、C# に何か問題があるように思えます。それが強い型であり、型 var を持たない場合。理解できない。おそらくこれが、C# 4.0 で Dynamic キーワードを導入した理由です。動的型付けと呼ばれるまったく新しい概念があります。では、動的型とは何でしょうか?まず、上記のキーワード var と同じ方法を使用して、コンパイル時にどのような型が表示されるかを確認してみましょう。下の図

に示すように、コンパイル中に型がまだ動的であるようです。確かに動的タイプがあるようです。もちろん、このようには機能しません。走行時の見た目にも注目する必要があります。 Visual Studio がどのようにデバッグするかを見てみましょう。

最初にブレークポイントを設定します。ライターの左端 (つまり、コードを記述する場所) をクリックするだけで、赤い点が表示されます。それがブレークポイントです。 Eclipseにはブレークポイントを設定するための右クリックオプションがあるようです。残念ながら、Visual Studio にはブレークポイントがありません。コードを作成する領域を右クリックすることによってのみブレークポイントを設定できます。読者の皆さんもぜひ試してみてください。

ブレークポイントが正常に設定されたら、(デバッグ モード) コードを開始します。現時点では、表示したい変数を監視できます。まず、対応する変数を選択して右クリックします。以下のように

「監視追加(W)」をクリックすると、対応する監視フォームがポップアップ表示されます。以下は、著者が対応するフォームを抜粋したものです。

わかりました。次のステップは、どうやって彼に次の一歩を踏み出してもらうかです。以下に示すツール ボタンが Visual Studio の上部に表示されます。

F5: 開始

F10: 次のステップ。 EclipseのF5に相当します。

F11: 内部コードを実行します。 EclipseのF6に相当します。

Shift+F11: 飛び出します。 EclipseのF7に相当します。

わかりました。誰でもデバッグできるはずだと思います。本題に入りましょう。上のモニタリング フォームから、学生のステータスの変動がわかります。型は動的{int}です。このようにして私たちは理解することができます。動的型は、実行時に決定される型です。

実際には動的型が存在するため、キーワード Dynamic はキーワード var とは異なります。したがって、定義時に初期化する必要はありません。対応する型は実行時にさらに決定できます。ぜひ試してみてください。

C#:

dynamic student = 1l;

if (student is int)
{
     Console.WriteLine("int类型");
}
else if (student is long)
{
    Console.WriteLine("long类型");
}

パラメータの変更

初期のメソッドには対応するデフォルト値がないことは誰もが知っています。そして、値は定義された順序で渡される必要があります。 C# では、この点に関していくつかの変更が加えられています。

public static void mothed(string a,string b = "bbb")
{
}

我们可以看到代段里面参数string b = "bbb"上面的改变了。这就意味着在调用mothed这个方法的时候，可以不给参数b传值。他会用默认的值：bbb。但是参数a就必须传了。代码如下

第一种用法：这个时候参了的值是默认值(bbb).

 mothed("aaa");

第二种用法：这跟以前的用法一样子。

mothed("aaa","ccc");

第三种用法：这新是一种用法。不用当然顺序的问题了。

mothed(b:"ccc",a:"a");

方法上的改变

不管是JAVA还是C#都有定义事件这个概念。那么C#是什么样子定义事件呢？

1.首先要用到关键字delegate声明该事件的委托类型。即是用于表示将来要发生事件的结构是什么。如要回返什么类型。会传入什么样子的参数类型。有几个参数。这些都可以开发人员自己定义。包括委托类型的名字。

 public delegate void MoveHandler(object obj);

注意上面的代码可以独立一个cs文件来存放他。跟类的代码存放的级别一样子。

2.定义好了委托类型之后，我们就可以根据这个委托类型来声明对应的事件。关键字event就是表示当前为事件的意思。然后在Move方法触发对应的事件。判断事件是不是空的。如果不是就触发事件。

C#：

public class Child : Person
    {
        public event MoveHandler ChildMoveHandler;
        public Child()
            : base("Aomi")
        {
 
        }
        public override void Move()
        {
            if (ChildMoveHandler != null)
                ChildMoveHandler(this);
        }
    }

3.有了上面的代码的声明之后，我们就可以试用一下C#的事件了。如下面的代码。在child变量调用Move方法之前。笔者就给他初始化一个事件。这个时候他在调用Move方法，判断事件不为空就把自己传给了这个事件做为参数。而下面的事件代码(Child_ChildMoveHandler方法)里面会把对应的obj通过as功能转化为Child类的变量。在打印出名字来。请一定要注意给事件赋值的时候要用"+="。即是增加事件不是赋值哦。相反"-="表示删除事件。

C#：

class Program
    {
        static void Main(string[] args)
        {
            Child child = new Child();
            child.ChildMoveHandler += Child_ChildMoveHandler;
            child.Move();
        }

        public static void Child_ChildMoveHandler(object obj)
        {
            Child src = obj as Child;
            Console.WriteLine(src.Name);
        }
        
    }

对于上面的三个步骤是以前的用法。现在有了新用法。引入了关键字Action的用法。简单来讲就传递方法了。以前只能传递变量或是对象。现在方法也可以传递了。事件声明就变得很简单了。

C#：

public class Child : Person
    {
        public event MoveHandler ChildMoveHandler;
        public event Action<object> ChildActionMoveHandler;
        public Child()
            : base("Aomi")
        {
 
        }
        public override void Move()
        {
            if (ChildMoveHandler != null)
                ChildMoveHandler(this);
            if (this.ChildActionMoveHandler != null)
                this.ChildActionMoveHandler(this);

        }
    }

对于上面的三个步骤是以前的用法。现在有了新用法。引入了关键字Action的用法。简单来讲就传递方法了。以前只能传递变量或是对象。现在方法也可以传递了。事件声明就变得很简单了。

C#：

public class Child : Person
    {
        public event MoveHandler ChildMoveHandler;
        public event Action<object> ChildActionMoveHandler;
        public Child()
            : base("Aomi")
        {
 
        }
        public override void Move()
        {
            if (ChildMoveHandler != null)
                ChildMoveHandler(this);
            if (this.ChildActionMoveHandler != null)
                this.ChildActionMoveHandler(this);

        }
    }

使用的方式还是不变得。如下代码

class Program
    {
        static void Main(string[] args)
        {
            Child child = new Child();
            child.ChildMoveHandler += Child_ChildMoveHandler;
            child.ChildActionMoveHandler += Child_ChildActionMoveHandler;
            child.Move();
        }

        public static void Child_ChildActionMoveHandler(object obj)
        {
            Child src = obj as Child;
            Console.WriteLine(src.Name);
        }

        public static void Child_ChildMoveHandler(object obj)
        {
            Child src = obj as Child;
            Console.WriteLine(src.Name);
        }
        
    }

看吧。事件的定义变得很简单了。只是对于Action的用法。可能还是一点不了解。Action这个是什么意思呢？很简单就是说Action他可以实现方法传递。只是可惜只能控制参数的类型和个数却不能控制返回类型。也是就说返回类型只能是void类型。那么控制返回的类型的话，不好意思请改用另一个关键字Func。这个时候就可以控制返回类型。只是不能用void作为返回类型了。代码如

public class Child : Person
    {
        public event MoveHandler ChildMoveHandler;
        public event Func<object,int> ChildFuncMoveHandler;
        public Child()
            : base("Aomi")
        {
 
        }
        public override void Move()
        {
            if (ChildMoveHandler != null)
                ChildMoveHandler(this);
            if (this.ChildFuncMoveHandler != null)
                this.ChildFuncMoveHandler(this);

        }
    }

执行代码：

class Program
    {
        static void Main(string[] args)
        {
            Child child = new Child();
            child.ChildMoveHandler += Child_ChildMoveHandler;
            child.ChildFuncMoveHandler += Child_ChildFuncMoveHandler;
            child.Move();
        }

        public static int Child_ChildFuncMoveHandler(object obj)
        {
            Child src = obj as Child;
            Console.WriteLine(src.Name);
            return 0;
        }

        public static void Child_ChildMoveHandler(object obj)
        {
            Child src = obj as Child;
            Console.WriteLine(src.Name);
        }
        
    }

显然不管是用Action关键字还是用Func关键字都是对方法的操作。但是在事件的声明上却变得更加的可读和简单了。至少不用在写声明委托类型了。既然对方法的操作。是不是可以这样了讲Action和Func可以定义为一个类内部的成员变量。当然可以。

public class Mothed
    {
        public Func<string, int> PrintFunc;
        public Action<string> PrintAction;

        public void Execute()
        {
            this.PrintFunc("PrintFunc aomi");
            this.PrintAction("PrintAction aomi");
        }
    }

看看执行代码吧

class Program
    {
        static void Main(string[] args)
        {
            Mothed mothed = new Mothed();
            mothed.PrintAction = PrintAction;
            mothed.PrintFunc = PrintFunc;
            mothed.Execute();
        }
        public static int PrintFunc(string value)
        {
            Console.WriteLine(value);
            return 0;
        }
        public static void PrintAction(string value)
        {
            Console.WriteLine(value);
        }
    }

很重要的一点：上面的事件是用“+=”，现在是用"="。即是赋值的意思了。

我们可以看到C#在把方法也变成一个可以使用的变量了。正因为这样子，在方法的赋值上出现俩种的方式写法。让我们看一下吧。

1.匿名方法赋值。

class Program
    {
        static void Main(string[] args)
        {
            Mothed mothed = new Mothed();
            mothed.PrintAction = delegate(string value)
            {
                Console.WriteLine(value);
            };
            mothed.PrintFunc = delegate(string value)
            {
                Console.WriteLine(value);
                return 0;
            }; 

            mothed.Execute();
        }
    }

2.lambda表达式赋值。

class Program
    {
        static void Main(string[] args)
        {
            Mothed mothed = new Mothed();
            mothed.PrintAction = (string value)=>
            {
                Console.WriteLine(value);
            };
            mothed.PrintFunc = (string value)=>
            {
                Console.WriteLine(value);
                return 0;
            }; 

            mothed.Execute();
        }
        
    }

本章总结    

本章主要是讲到关于C#在语法上引入的一些新的特性。其中有一些还是值得我们去注意的。特别事件声明用的action和func。其次便是参数上的变化。这个笔者在开发过程也常常会用到。