Jim Fawcett CSE681 – Software Modeling and Analysis Fall 2005 Visual Studio 2005 Jim Fawcett CSE681 – Software Modeling and Analysis Fall 2005

References C# Programming Language, Anders Hejlsberg, et. al., Addison-Wesley, 2004 Pro C# 2005, and the .Net 2.0 Platform, Andrew Troelsen, Apress 2005 Visual C#, A Developer’s Notebook, Jesse Liberty, OReilly, 2005 ASP.NET 2.0, Core Reference, Dino Exposito, Microsoft Press, 2005

Additions to C# Generics Iterators Anonymous Methods Partial Types Static Classes Nullable Type Delegate Covariance and Contravariance

C# Generics C++ Class Template Syntax: template <class T> class stack { … }; stack<widget> wStack; C# Generics Syntax public class stack<T> { … } stack<widget> wStack = new stack<widget>();

Comparison C++ Templates CLR Generics Type safe Bind at compile time Has specializations Supports template methods Supports partial template specialization Does not need constraints Calls on methods of a parameter type can be checked because the parameter type is known then. Does not share implementations for any type CLR Generics Type safe Bind at run-time No specializations Supports Generic methods Uses constraints Supports compile-time verification that methods called on a parameter type are correct Shares implementation among all instances for reference types Does not share implementations for value types

Second Look at Generics The “shares implementation for reference types” is important. It says that generics are essentially cosmetic. We don’t have to explicitly cast items extracted from a generic container, but the underlying representation is still object. The explicit cast we had to do is now done by the generic machinery, but we still pay the performance hit for the cast.

Constraints on Generics Constraints are an optional list of type requirements declared with the where keyword: Public class Dictionary<k,v> where k : IComparable { public void Add( k key, v value ) { … // constraint tells compiler that object key has // CompareTo() method if ( key.CompareTo(x) < 0 ) { … } … } }

Iterators An iterator block is a block that yields an ordered sequence of values. An iterator block is distinguished by the presence of one or more yield statements. A function that contains this block may not have out or ref parameters or a return statement. See example on next slide.

Iterator Example Class stack<T> : IEnumerable<T> { T[ ] items; int count; : public IEnumerator<T> GetEnumerator() { for(int i = count-1; i>=0; --i) yield return items[i]; } } Note that the operation of this function is NOT what its code advertises.

Anonymous Methods Anonymous methods support creation of an inline delegate: public delegate void aDelType(string); public event aDelType aDel; : aDel += delegate(string str) { // code }; The delegate arguments may be omitted if the code does not use them.

Method Group Conversions An implicit conversion exists from a method group to a compatible delegate: public delegate void aDelType(string); public event aDelType aDel; : void myHandler(string str) { … } : aDel += myHandler; Here, aDelType(string) is a method group.

Partial Types A C# class can now be split across two or more files. The visual studio wizards now place designer code in a separate file, so you don’t have to print that when you want a hard copy of the class. Syntax: public partial class my class { // code } public partial class my class { // more code } Now we can print out all the developer’s code without having to display the designer code.

Static Classes A class can be declared as static: All class members are static. You can not use new to instantiate an instance. They may not define instance constructors. They are sealed.

Nullable Type Represents a value of type T that may be null: Nullable<int> x = null; Nullable<string> y = null; Can be used to represent: nullable columns in a database optional attributes in an XML element

Delegate Covariance and Contravariance Covariance permits a delegate typed to invoke a method with base return type to bind to a function returning a class derived from base. Contravariance permits a delegate typed to invoke a method with base parameters to bind to a function passing derived parameters, supporting polymorphism.

Visual Studio IDE Changes to the IDE Can save several IDE configuration settings to suit specific tasks UML diagrammer / code generator Code Refactoring Tool Code Snippets Improved Object Viewer in Debugger Debugging Visualizers

Support for Cleaning up and Documenting Code Create UML diagrams from classes and classes from UML diagrams. Refactor Code Change method or parameter name everywhere Factor out method by selecting lines

Create UML Class Diagrams with Code and Vice Versa

Refactor Code

Code Snippets Select code, right-click, and select code snippet: Get context menu with choices like if, for, while, … Wraps code with the selected construct in an intelligent, easy-to-use way.

Debugging Visualizers

WinForms Many New Controls: Asynchronous Tasks One-click Deployment Tools strips Validation Window splitter Asynchronous Tasks One-click Deployment

New Controls, Better Object View

Asynchronous Tasks Uses BackgroundWorker class RunWorkerAsync raises a DoWork event That causes a Designer wired delegate to call backgroundWorker1_DoWork(sender,args);

Asynchronous Tasks

WebForms No longer need IIS for development Built-in Forms-based security Roles Master pages Themes Personalization support Easier data access

Samples and Help, C#

Samples and Help, C++

Samples and Help, ASP.Net