Java greift C# an – Verbesserung der Syntax-Wissenspunkte

1. Klasseninitialisierungsmethode. Wenn die Klasse initialisiert wird, wird die Funktion zum Initialisieren von Attributwerten hinzugefügt. Der folgende Code.

Bisher:

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

Neu:

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

2. Initialisierungsmethode der Sammlungsklasse. Die Initialisierung von Sammlungsklassen ist nicht mehr so ​​eintönig wie früher. Während der Initialisierung können Sie einige Werte hinzufügen.

Vorheriges:

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

Neu

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

Einführung des Schlüsselworts var

Die Typen, die wir in den vorherigen Kapiteln häufig verwenden, sind alle stark getippt. Wenn Sie Javascript-Sprache verwendet haben, sollten Sie meines Erachtens über schwaches und starkes Typing Bescheid wissen. Vereinfacht ausgedrückt bedeutet eine schwache Typisierung, dass der Typ bei der Definition schwer zu bestimmen ist. Erst beim Laufen wissen Sie, um welchen Typ es sich handelt. C# ist eine stark typisierte Sprache, was bedeutet, dass Sie beim Kompilieren wissen müssen, welche Art von Daten definiert wird. Allerdings verwirrt mich C# in diesem Punkt. Warum sagst du das so? Schauen Sie sich den folgenden Code an.

var local = 1;

Dieser Code ist eine Definition... In Ordnung. Auch der Autor weiß nicht, was er sagen soll. Es gibt relevante Informationen, die in etwa so lauten. Er ist nicht ohne Typ. Es ist auch kein Var-Typ. Es wird jedoch beim Kompilieren festgestellt, um welchen Typ es sich handelt. Wenn der obige Code kompiliert wird, wird festgestellt, dass er vom Typ int ist. Im Bild unten

sehen Sie beispielsweise die Eingabeaufforderung im Bild oben. Es ist eine lokale Variable int local. Es zeigt deutlich, dass es sich um einen int-Typ handelt. Während des Entwicklungsprozesses ist der Autor nie auf die Notwendigkeit gestoßen, das Schlüsselwort var zum Deklarieren von Variablen zu verwenden. Daher hat der Autor in meinem Herzen nie verstanden – wann sollte dies verwendet werden? Hier gibt es ein wenig Syntax zu beachten. Ich habe gerade erwähnt, dass C# eine stark typisierte Sprache ist. Daher muss dem Schlüsselwort var bei seiner Definition ein initialisierter Wert zugewiesen werden.

Durch die Einführung des Schlüsselworts var entstand auch eine Möglichkeit, Klassendeklarationen zu schreiben. Viele Bücher nennen sie anonyme Typen. Der folgende Code

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

führt das Schlüsselwort „dynamic“ ein

Der Autor erwähnte oben, dass C# eine stark typisierte Sprache ist. Die Einführung des Schlüsselworts var ist wirklich schwer zu verstehen. Wenn der Autor sagt, dass es sich um einen schwachen Typ handelt, scheint mit C# etwas nicht in Ordnung zu sein. Wenn es sich um einen starken Typ handelt und nicht den Typ var hat. Ich verstehe nicht. Vielleicht hat C# deshalb in 4.0 das Schlüsselwort „dynamic“ eingeführt. Es gibt ein brandneues Konzept namens dynamisches Tippen. Was sind also dynamische Typen? Lassen Sie uns zunächst dieselbe Methode wie das Schlüsselwort var oben verwenden, um zu sehen, welcher Typ beim Kompilieren angezeigt wird. Wie im Bild unten gezeigt, scheint

während der Kompilierung vom dynamischen Typ zu sein. Es scheint, dass es tatsächlich dynamische Typen gibt. So funktioniert das natürlich nicht. Wir müssen uns auch ansehen, wie es beim Laufen aussieht. Schauen Sie sich einfach an, wie Visual Studio debuggt.

Setzen Sie zuerst einen Haltepunkt. Klicken Sie einfach ganz links auf den Writer (d. h. dort, wo Sie Code schreiben) und ein roter Punkt wird angezeigt. Das ist der Haltepunkt. Eclipse scheint eine Rechtsklick-Option zum Festlegen eines Haltepunkts zu haben. Leider verfügt Visual Studio nicht über diese Funktion. Sie können Haltepunkte nur festlegen, indem Sie mit der rechten Maustaste auf den Bereich klicken, in dem Sie Code schreiben. Liebe Leser, bitte probieren Sie es selbst aus.

Nachdem der Haltepunkt erfolgreich festgelegt wurde, starten Sie den Code (Debug-Modus). Zu diesem Zeitpunkt können wir die Variablen überwachen, die wir anzeigen möchten. Wählen Sie zunächst die entsprechende Variable aus und klicken Sie mit der rechten Maustaste. Wie folgt:

Wenn Sie auf „Überwachung hinzufügen (W)“ klicken, wird das entsprechende Überwachungsformular angezeigt. Unten ist der Autor, der das entsprechende Formular herausholt.

Okay. Der nächste Schritt besteht darin, ihn dazu zu bringen, den nächsten Schritt zu tun. Die unten gezeigten Werkzeugschaltflächen werden oben in Visual Studio angezeigt.

F5: Start

F10: Nächster Schritt. Entspricht dem F5 von Eclipse.

F11: Internen Code ausführen. Entspricht dem F6 von Eclipse.

Umschalttaste F11: Herausspringen. Entspricht dem F7 von Eclipse.

Okay. Ich glaube, dass jeder in der Lage sein sollte, es zu debuggen. Kommen wir zur Sache. Aus dem Überwachungsformular oben können wir den variablen Studentenstatus erkennen. Der Typ ist „dynamic{int}“. So können wir es verstehen. Dynamische Typen sind Typen, die zur Laufzeit ermittelt werden.

Das Schlüsselwort „Dynamic“ unterscheidet sich vom Schlüsselwort „Var“, da es sich tatsächlich um einen dynamischen Typ handelt. Es ist also nicht erforderlich, es beim Definieren zu initialisieren. Der entsprechende Typ kann zur Laufzeit weiter bestimmt werden. Machen Sie sich nicht die Mühe, es auszuprobieren.

C#:

dynamic student = 1l;

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

Parameteränderungen

Wir alle wissen, dass die frühen Methoden keine entsprechenden Standardwerte hatten. Und die Werte müssen in einer definierten Reihenfolge übergeben werden. C# hat diesbezüglich einige Änderungen vorgenommen.

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。其次便是参数上的变化。这个笔者在开发过程也常常会用到。