c 3 0
Download
Skip this Video
Download Presentation
C# 3.0

Loading in 2 Seconds...

play fullscreen
1 / 31

C# 3.0 - PowerPoint PPT Presentation


  • 239 Views
  • Uploaded on

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

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'C# 3.0' - bernad


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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
c 3 0

C# 3.0

Tom Roeder

CS215 2006fa

version 3
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
implicitly typed variables
Implicitly typed variables
  • var i = 5;var s = "Hello";var d = 1.0;var orders = new Dictionary();
  • 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
extension methods
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
extension methods1
Extension methods

public static class Extensions

{

public static int ToInt32(this string s) {

return Int32.Parse(s); }

public static T[] Slice(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; }

}

extension methods2
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) { }}

extension methods3
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"); }}

extension methods4
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
lambda expressions
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
lambda expressions1
Lambda expressions
  • Can be converted to delegate type
    • if parameters and body match
    • delegate R Func(A arg);Func f1 = x => x + 1;Func f2 = x => x + 1; Func f3 = x => x + 1;
  • Participate in type inference
  • If expression body, get expression trees
lambda expressions2
Lambda expressions
  • Type inferencepublic static IEnumerable Select( this IEnumerable source, Func selector) { foreach (T element in source) yield return selector(element); }
  • If call Select(customers, c => c.Name);
    • T, S mapped to appropriate types
lambda expressions3
Lambda expressions
  • Given the code

delegate R Func(A arg);static Z F(X value, Func f1, Func f2) { return f2(f1(value));}

    • what happens when get the following?F("1:15:30", s => TimeSpan.Parse(s), t => t.TotalSeconds)
intializers
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 digits = new List { 0, 1};
    • Must implement System.Generic.ICollection
  • Object initializers
    • var a = new Point { X = 0, Y = 1 };
anonymous types
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
query expressions
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.
query expressions1
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
other clauses
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 }
other clauses1
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
query expression pattern
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
sequences
Sequences
  • A collection IEnumerable
    • given iterator, can be viewed as a sequence
  • New extension operators
    • Take/TakeWhile
    • Skip/SkipWhile
    • Reverse
    • Concat
    • Intersect/Union/Except
expression trees
Expression trees
  • Data structure that represents expression
  • type Expression if D is delegate type
    • eg. Expression> e = x => x + 1;
    • can be used to parse the function
  • Spec not currently available
  • Idea
    • take an expression tree and convert to SQL
database integration
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;
dlinq attributes
DLinq Attributes
  • [Table(Name="DVDTable")]public class DVD{ [Column(Id = true)] public string Title;

[Column] public string Rating;}

connections revisited
Connections Revisited
  • public class MyDVDs : DataContext{ public Table 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;
dlinq query expressions
DLinq Query Expressions
  • var x =
    • the query is not executed immediately
    • why not?
  • Convert to Query
    • holds the actual query as an Expression tree
    • convert to SQL at execution time. When?
    • eg. when need IEnumerator for foreach
changes
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
transactions
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
xlinq
XLinq
  • Instant XML intro
    • language for defining markup
    • nested tags and attributes
    • eg Tom Roeder
  • XML used as a document language
    • often want to extract information from XML
    • eg. in web search
  • What is the relationship to DBs?
c xml programming
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
xlinq query example
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
c 3 0 conclusions
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
ad