1 / 31

C# 3.0

C# 3.0. Tom Roeder CS215 2006fa. Version 3. From PDC 2005 preview compiler available LINQ: language-integrated query High level points: adds native query functionality to C# adds better functional programming Several changes required to make this work implicitly typed variables

bernad
Télécharger la présentation

C# 3.0

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. C# 3.0 Tom Roeder CS215 2006fa

  2. Version 3 • From PDC 2005 • preview compiler available • LINQ: language-integrated query • High level points: • adds native query functionality to C# • adds better functional programming • Several changes required to make this work • implicitly typed variables • extension methods

  3. Implicitly typed variables • var i = 5;var s = "Hello";var d = 1.0;var orders = new Dictionary<int,Order>(); • Type of the variable induced from expression • must include initializer • can’t be null. Why not? • What happens if “var” is a class in scope? • Works in for loops

  4. Extension methods • Can add methods to other classes • any methods (although look static) • only from static classes • When import a namespace that has extensions, then added to classes • once imported, called as usual • Local methods take precedence • first local for normal method, then extension

  5. Extension methods public static class Extensions { public static int ToInt32(this string s) { return Int32.Parse(s); } public static T[] Slice<T>(this T[] source, int index, int count) { if (index < 0 || count < 0 || source.Length – index < count) throw new ArgumentException(); T[] result = new T[count]; Array.Copy(source, index, result, 0, count); return result; } }

  6. Extension methods using N1; namespace N1{ public static class E { public static void F(this object obj, int i) { } public static void F(this object obj, string s) { } }} class A { } class B{ public void F(int i) { }} class C{ public void F(object obj) { }}

  7. Extension methods class X{ static void Test(A a, B b, C c) { a.F(1); a.F("hello"); b.F(1); b.F("hello"); c.F(1); c.F("hello"); }}

  8. Extension methods • Not for properties, events, operators • currently under consideration • Equivalent to calling the static method • difference from actually extending the class? • How could we use this for Polynomials? • Disadvantages? • implicitness • security

  9. Lambda expressions • Generalized function syntax •  x . x + 1 • in C# 3.0, have x => x + 1 • From anonymous delegate syntax: • delegate(int x) { return x + 1;} • Can have implicitly typed variables • Can have more than one variable • Can have expression or statement body • NB: no statement bodies in preview compiler

  10. Lambda expressions • Can be converted to delegate type • if parameters and body match • delegate R Func<A,R>(A arg);Func<int,int> f1 = x => x + 1;Func<int,double> f2 = x => x + 1; Func<double,int> f3 = x => x + 1; • Participate in type inference • If expression body, get expression trees

  11. Lambda expressions • Type inferencepublic static IEnumerable<S> Select<T,S>( this IEnumerable<T> source, Func<T,S> selector) { foreach (T element in source) yield return selector(element); } • If call Select(customers, c => c.Name); • T, S mapped to appropriate types

  12. Lambda expressions • Given the code delegate R Func<A,R>(A arg);static Z F<X,Y,Z>(X value, Func<X,Y> f1, Func<Y,Z> f2) { return f2(f1(value));} • what happens when get the following?F("1:15:30", s => TimeSpan.Parse(s), t => t.TotalSeconds)

  13. Intializers • Can initialize fields like attribute fields • new C(1, 2, name=“my class”); • works if public field or if property with set • can be nested (eg. Rectangle with two Points) • Collection initializers • List<int> digits = new List<int> { 0, 1}; • Must implement System.Generic.ICollection<T> • Object initializers • var a = new Point { X = 0, Y = 1 };

  14. Anonymous types • var x = new {p1 = 10, p2 = “name”}; • x is of anonymous type • type can’t be referred to by name in program • structural type equivalence • two anonymous types can be compatible • implicitly typed arrays • var a = new[] { 1, 10, 100, 1000 }; • must have consistent types • or have implicit conversions

  15. Query expressions • Adds querying to language • important for interaction with DB • but also with built-in data structures • leave query planning to data structure designer • Implemented using above functionality • anonymous types and variables useful • lambda expressions make it cleaner.

  16. Query expressions • eg.var x = from s in students where s.City == “Ithaca" select s; • defines an expression • translates to invocation of Where method on students • if select contains expression, calls Select • uses lambda expressions as parameters • we saw Select above

  17. Other clauses • groupby • from c in customers group c.Name by c.Country • c.GroupBy(c => c.Name, c => c.Country); • orderbyfrom c in customersorderby c.Nameselect new { c.Name, c.Phone } • multiple from clausesfrom c in customerswhere c.City == "London"from o in c.Orderswhere o.OrderDate.Year == 2005select new { c.Name, o.OrderID, o.Total }

  18. Other clauses • inner join? • can be done with multiple generators • just use a different object internally • not as efficient? • maybe need more syntax? • don’t have full spec yet, just examples

  19. Query expression pattern • As with collections: • not an interface • just need to implement the methods • necessary for backwards compatibility • methods may be implemented by extension • Methods named as above • Any class that implements pattern can be accessed via the new syntax

  20. Sequences • A collection IEnumerable<T> • given iterator, can be viewed as a sequence • New extension operators • Take/TakeWhile • Skip/SkipWhile • Reverse • Concat • Intersect/Union/Except

  21. Expression trees • Data structure that represents expression • type Expression<D> if D is delegate type • eg. Expression<Func<T>> e = x => x + 1; • can be used to parse the function • Spec not currently available • Idea • take an expression tree and convert to SQL

  22. Database Integration • Final step • don’t think about the database types as separate • allow databases to back classes! • How would you do this in C#? • Queries are now in the language • eg. var x = from s in sources where s.fileName == “Polynomial.cs” select s;

  23. DLinq Attributes • [Table(Name="DVDTable")]public class DVD{ [Column(Id = true)] public string Title; [Column] public string Rating;}

  24. Connections Revisited • public class MyDVDs : DataContext{ public Table<DVD> DVDs; public MyDVDs(string connection) : base(connection) {}} • creates the connection to a database • MyDVDs db = new MyDVDs(“dvd.mdf”);var x = from d in db.DVDs where d.Rating == “G” select d;

  25. DLinq Query Expressions • var x = <some query> • the query is not executed immediately • why not? • Convert to Query<DVD> • holds the actual query as an Expression tree • convert to SQL at execution time. When? • eg. when need IEnumerator for foreach

  26. Changes • db.SubmitChanges() • try to update the DB with our changes • may fail: why? • other applications may have made modifications • what should we do? • db.RejectChanges() • throw away all changes since last updated • Concurrency control • optimistic in general

  27. Transactions • Transaction: unit of work • isolated from other units • can be made to look like happening serially • using(TransactionScope ts = new TransactionScope()) { db.SubmitChanges(); ts.Complete();} • creates a new transaction for these updates • if transaction succeeds, all changes accepted • if transaction aborts, no object rollback

  28. XLinq • Instant XML intro • language for defining markup • nested tags and attributes • eg <name instructor=“true”>Tom Roeder</name> • XML used as a document language • often want to extract information from XML • eg. in web search • What is the relationship to DBs?

  29. C# XML Programming • Current model • Read in XML document via various methods • everything based in XMLDocument • XLinq model • XElement • no document requirements: can be created anywhere • can be queried as in DLinq • built up functionally

  30. XLinq Query Example • from c in contacts.Elements("contact")where (string) c.Element("address").Element("state") == "WA"orderby (string) c.Element("name")select (string) c.Element("name"); • What is the difference with DLinq? • why all the casts? • how to fix? • LINQ team looking into schema support • adds metadata to XML queries

  31. C# 3.0 Conclusions • query ability useful but many things are • adding functional programming increases the possible styles of C# programming • additions apparently not made on general principles but to support a particular narrow model of programming. • Nonetheless: try it out

More Related