19. Einführung in C# 2.0
C# 2.0 führt mehrere Spracherweiterungen ein, von denen die wichtigsten Generika, anonyme Methoden, Iteratoren und unvollständige Typen (Teiltypen) sind.
Generika ermöglichen die Parametrisierung von Klassen, Strukturen, Schnittstellen, Delegaten und Methoden anhand der Art der Daten, die sie speichern und bearbeiten. Generika sind nützlich, da sie eine stärkere Typprüfung zur Kompilierungszeit ermöglichen und so explizite Konvertierungen zwischen Datentypen sowie Boxing-Operationen und Typprüfungen zur Laufzeit reduzieren.
Anonyme Methoden ermöglichen es Codeblöcken, sich inline dort einzuschleichen, wo der Delegate-Wert erwartet wird. Anonyme Methoden ähneln Lambda-Funktionen in der Programmiersprache Lisp. C# 2.0 unterstützt die Erstellung von „Closures“, in denen anonyme Methoden auf relevante lokale Variablen und Parameter zugreifen können.
Iteratoren sind Methoden, die inkrementell Werte berechnen und erzeugen können. Iteratoren erleichtern es einem Typ, anzugeben, wie eine foreach-Anweisung alle ihre Elemente durchläuft.
Unvollständige Typen ermöglichen die Aufteilung von Klassen, Strukturen und Schnittstellen in mehrere Teile und die Speicherung in verschiedenen Quelldateien, was der Entwicklung und Wartung zuträglicher ist. Darüber hinaus ermöglichen unvollständige Typen die Trennung zwischen maschinell generierten und vom Benutzer geschriebenen Teilen bestimmter Typen, sodass die Erweiterung des vom Tool erstellten Codes einfach ist.
In diesem Kapitel werden diese neuen Funktionen vorgestellt. Nach dieser Einführung enthalten die nächsten vier Kapitel vollständige technische Spezifikationen dieser Funktionen.
C# 2.0-Spracherweiterungen sind in erster Linie darauf ausgelegt, maximale Kompatibilität mit vorhandenem Code sicherzustellen. Obwohl C# 2.0 beispielsweise den Wörtern „where“, „yield“ und „partial“ in bestimmten Kontexten besondere Bedeutungen zuweist, können diese Wörter dennoch als Bezeichner verwendet werden. Tatsächlich fügt C# 2.0 keine Schlüsselwörter hinzu, die mit Bezeichnern im vorhandenen Code in Konflikt geraten könnten.
19.1 Generics
Generics ermöglichen die Parametrisierung von Klassen, Strukturen, Schnittstellen, Delegaten und Methoden durch die Art der Daten, die sie speichern und bearbeiten. C#-Generika werden Benutzern von Eiffel- oder Ada-Generika oder Benutzern von C++-Vorlagen vertraut sein, sie müssen sich jedoch nicht länger mit den vielen Komplexitäten der Letzteren herumschlagen.
19.1.1 Warum Generika verwenden
Ohne Generika können allgemeine Datenstrukturen den Objekttyp zum Speichern beliebiger Datentypen verwenden. Die folgende Stack-Klasse speichert beispielsweise Daten in einem Objektarray und ihre beiden Methoden Push und Pop verwenden Objekte, um entsprechend Daten zu empfangen und zurückzugeben.
public class Stack { object[] items; int count; public void Push(object item){…} public object Pop(){…} }
Obwohl die Verwendung des Typobjekts die Stack-Klasse flexibler machen kann, ist sie nicht ohne Nachteile. Sie können beispielsweise einen Wert eines beliebigen Typs, beispielsweise eine Instanz von „Customer“, auf den Stapel verschieben. Wenn Sie jedoch einen Wert zurückerhalten, muss das Ergebnis der Pop-Methode explizit in den entsprechenden Typ umgewandelt werden, und es ist lästig, Code für eine Laufzeit-Typprüfung zu schreiben, und die daraus resultierenden Leistungseinbußen.
Stack stack = new Stack(); Stack.Push(new Customer()); Customer c = (Customer)stack.Pop();
Wenn ein Werttyp, z. B. ein int, an die Push-Methode übergeben wird, wird er automatisch geboxt. Wenn das int später abgerufen wird, muss es mithilfe einer expliziten Umwandlung entpackt werden.
Stack stack = new Stack(); Stack.Push(3); int I = (int)stack.Pop();
Solche Box- und Unboxing-Vorgänge erhöhen den Leistungsaufwand, da sie eine dynamische Speicherzuweisung und Laufzeittypprüfung erfordern.
Das größere Problem mit der Stack-Klasse besteht darin, dass sie die Art der auf dem Stack platzierten Daten nicht erzwingen kann. Tatsächlich kann eine Kundeninstanz auf den Stapel verschoben und beim Abrufen in den falschen Typ umgewandelt werden.
Stack stack = new Stack(); Stack.Push(new Customer()); String s = (string)stack.Pop();
Obwohl der vorherige Code eine unangemessene Verwendung der Stack-Klasse darstellte, ist dieser Code technisch korrekt und meldet keinen Fehler bei der Kompilierung. Das Problem tritt erst auf, wenn der Code ausgeführt wird. Zu diesem Zeitpunkt wird eine InvalidCastException ausgelöst.
Wenn die Stack-Klasse die Möglichkeit hätte, den Typ ihrer Elemente anzugeben, dann würde sie offensichtlich von dieser Fähigkeit profitieren. Durch den Einsatz von Generika wird dies möglich.
19.1.2 Generika erstellen und verwenden
Generika stellen Werkzeuge zum Erstellen von Typen mit Typparametern bereit. Das folgende Beispiel deklariert eine generische Stack-Klasse mit einem Typparameter T. Typparameter werden in den Trennzeichen „<“ und „>“ angegeben. Es findet keine Konvertierung zwischen Objekt- und anderen Typen von Stack
Public class Stack<T> { T[] items; int count; public void Push(T item){…} public T Pop(){…} }
当泛型类Stack
Stack<int> stack = new Stack<int>(); Stack.Push(3); int x = stack.Pop();
Stack
泛型提供了强类型,意义例如压入一个int到Customer对象堆栈将会出现错误。就好像Stack
对于下面的例子,编译器将会在最后两行报告错误。
Stack<Customer> stack = new Stack<Customer>(); Stack.Push(new Customer()); Customer c = stack.Pop(); stack.Push(3); //类型不匹配错误 int x = stack.Pop(); //类型不匹配错误
泛型类型声明可以有任意数量的类型参数。先前的Stack
public class Dictionary<K , V> { public void Add(K key , V value){…} public V this[K key]{…} } 当Dictionary<K , V> 被使用时,必须提供两个类型参数。 Dictionary<string , Customer> dict = new Dictionary<string , Customer>(); Dict.Add(“Peter”, new Customer()); Custeomer c = dict[“Perter”];
19.1.3泛型类型实例化
与非泛型类型相似,被编译过的泛型类型也是由中间语言[Intermediate Language(IL)]指令和元数据表示。泛型类型的表示当然也对类型参数的存在和使用进行了编码。
当应用程序首次创建一个构造泛型类型的实例时,例如,Stack
.NET公共语言运行时使用值类型为每个泛型类型实例创建了一个本地代码的特定拷贝,但对于所有的引用类型它将共享那份本地代码的单一拷贝(因为,在本地代码级别,引用只是带有相同表示的指针)。
19.1.4约束
一般来讲,泛型类不限于只是根据类型参数存储值。泛型类经常可能在给定类型参数的类型的对象上调用方法。例如,Dictionary
public class Dictionary<K , V> { public void Add(K key , V value) { … if(key.CompareTo(x)<0){…}//错误,没有CompareTo方法 … } }
因为为K所指定的类型参数可能是任何类型,可以假定key参数存在的唯一成员,就是那些被声明为object类型的,例如,Equals,GetHashCode和ToString;因此,在先前例子中将会出现编译时错误。当然,你可以将key参数强制转换到一个包含CompareTo方法的类型。例如,key参数可能被强制转换到IComparable接口。
public class Dictionary<K , V> { public void Add(K key , V value) { … if(((IComparable)key).CompareTo(x)<0){…} … } }
尽管这种解决办法有效,但它需要在运行时的动态类型检查,这也增加了开销。更糟糕的是,它将错误报告推迟到了运行时,如果键(key)没有实现IComparable接口将会抛出InvalidCastException异常。
为了提供更强的编译时类型检查,并减少类型强制转换,C#允许为每个类型参数提供一个约束(constraint)的可选的列表。类型参数约束指定了类型必须履行的一种需求,其目的是为了为类型参数被用作实参(argument)。约束使用单词where声明,随后是类型参数的名字,接着是类或接口类型的列表,和可选的构造函数约束new()。
public class Dictionary<K, V> where K :IComparable { public void Add(K key , V value) { … if(key.CompareTo(x)<0){…} … } }
给定这个声明,编译器将会确保K的任何类型实参是实现了IComparable接口的类型。
并且,在调用CompareTo方法之前也不再需要对key参数进行显式地强制转换。为类型参数作为一个约束而给出的类型的所有成员,对于类型参数类型的值时直接有效的。
对于一个给定的类型参数,你可以指定任意数量的接口作为约束,但只能有一个类。每个约束的类型参数有一个单独的where 语句。在下面的例子中,类型参数K有两个接口约束,类型参数e有一个类约束和一个构造函数约束。
public class EntityTable<K, E> where K:IComparable<K>,IPersisable where E:Entity, new() { public void Add(K key , E entity) { … if(key.CompareTo(x)<0){…} … } }
在前面的例子中,构造函数约束new(),确保为E用作类型参数的类型具有一个公有的、无参数构造函数,并且它允许泛型类使用new E()创建该类型的实例。
类型参数约束应该很小心的使用。尽管它们提供了更强的编译时类型检查,在某些情况下增强了性能,但它们也限制了泛型类型的可能的用法。例如,泛型类List
以上就是C# 2.0 Specification(一)简介的内容,更多相关内容请关注PHP中文网(www.php.cn)!