Your SlideShare is downloading. ×
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
ASP.NET 3.5 SP1
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×
Saving this for later? Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime – even offline.
Text the download link to your phone
Standard text messaging rates apply

ASP.NET 3.5 SP1

3,850

Published on

ASP.NET 3.5 SP1

ASP.NET 3.5 SP1

Published in: Technology
0 Comments
1 Like
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total Views
3,850
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
8
Comments
0
Likes
1
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide
  • Talking Points: .NET 3.5 SP1 contains four major feature additions (listed). These new features are aimed at enriching the web development and data programmability spaces. Let’s take a moment to examine each of these new features individually…
  • Talking Points: When we talk about the Entity Framework, we’re actually talking about two things: The Entity Data Model (EDM) The Entity Framework It’s important to delineate the two as separate, but complementing technologies The Entity Framework is a set of services that allow you to consume an EDM from within your applications. Object services is a set of classes that allow you to query an EDM and retrieve your results in the form of strongly-typed CLR objects. Entity Client allows you to query an EDM using a traditional ADO.NET paradigm (EntityConnection, EntityDataReader, etc.) Provides a smooth migration path for developers that are new to the Entity Framework Offers performances benefits due to the lack of object materialization Entity SQL is a SQL-like language that let’s you query your EDM with full control. Unlike SQL, Entity SQL queries the conceptual model, so your queries can be expressed in terms of the way your application sees your model, not how your database is actually shaped. LINQ To Entities sits on top of Object Services and allows you to retrieve strongly-typed objects from your EDM, expressed through familiar LINQ query syntax.The Entity Framework is RDMS agnostic, and numerous database vendors are currently developing providers: Oracle, DB2, MySQL, PostgreSQL, VistaDB, SQLite, Sybase, Informix, etc.
  • Estimated Time: 6 minutesTalking Points: When we talk about the Entity Framework, we’re actually talking about two things: The Entity Data Model (EDM) The Entity Framework It’s important to delineate the two as separate, but complementing technologies The EDM is a set of layers that make up your application’s model, as well as it’s mapping to an underlying data store. Made up of three files: CSDL (Conceptual Schema Definition Language) MSL (Mapping Specification Language) SSDL (Storage Schema Definition Language) This separation of concerns allows great flexibility: Model your application the way you want regardless of the state/structure of its underlying data store Normalize your database as much as you need without worrying about affecting the interface of the application’s object model The EDM represents a re-useable application model that can be leveraged from within many applications/environments and persisted across numerous databases. The Entity Data Model is RDMS agnostic, and numerous database vendors are currently developing providers: Oracle, DB2, MySQL, PostgreSQL, VistaDB, SQLite, Sybase, Informix, etc. The Entity Data Model primarily of three main concepts: Entities, which represent your domain objects. Associations, which represent a relationship between two entities. Functions, which represent stored procedures or UDFs in your database that can be mapped to model-level functionality. Because there will be plenty of situations where you’ll need to use stored procedures, the Entity Data Model allows you to map functions in your model to a store procedure in your database. This is useful because you can leverage a stored procedure without having to write ADO.NET code to call it, you can simply call a function on your model. EDM functions are represented as methods on your ObjectContext class.
  • EFConsoleDemoTO DO:Add EDM for Northwind Customers and Orders
  • Estimated Time: 1 minuteTalking Points: Now that we’ve seen the Entity Data Model, let’s see how to work with it using the Entity Framework. The Entity Framework is a set of services that allow you to consume an EDM from within your applications:Entity Client Entity SQL Object Services Entity SQL LINQ To Entities We’ll take a look at the 3 different flavors on consumption in detail, and discuss why and when you would use each one.
  • Estimated Time: 4 minutesTalking Points: The Entity Client is an Entity Framework “port” of the familiar object model of classes used in traditional ADO.NET programming, including:EntityCommandEntityConnectionEntityConnectionStringBuilderEntityDataReaderEntityParameterEntityTransaction Because of this fact it makes it a prime choice for developers migrating to the Entity Framework from ADO.NET. Just like traditional ADO.NET, your queries are returned as sequential text-based data that can iterated over using an EntityDataReader. This is great for performance, but lacks the rich object model that was created as part of your EDM. Entity Client gives you read-only access to your EDM. If data modification is required, you’ll have to use Object Services, which we’ll talk about in a bit. When using Entity Client, your queries are written using Entity SQL, which we’ll talk about in the next slide.
  • Estimated Time: 4 minutesTalking Points: Entity SQL is a query language that is syntactically very similar to SQL, but serves the sole-purpose of querying an EDM. Because it is meant for querying your EDM, this means your queries are written against your conceptual model, not your underlying data store. This higher-level abstraction allows you to write a textual query that is database agnostic. The translation from Entity SQL to T-SQL or PL/SQL (or whatever flavor your underlying data uses), is done by the selected ADO.NET Provider. Here we see a simple example that shows the same query written in T-SQL as well as Entity SQL. Notice that in Entity SQL we don’t have to do any joins, because the notion of relationships are first-class in our conceptual model. As a result, our query is half the size as the T-SQL version. Notice the use of the “Length” function in our Entity SQL example. This is called a “Canonical Function”, which is a high-level abstraction of a database function that will be translated into it’s respective database-specific flavor by your underlying provider
  • Estimated Time: 10 minutesDescription:At this point show some demos that consume the EDM we created in the last demo using Entity Client. Show a few simple queries highlighting some basic Entity SQL.
  • Estimated Time: 5 minutesTalking Points: While the Entity Client API is great and performant, it lacks the use of our created object model, as well as the ability to update data in our model. The Object Services API sits on top of Entity Client, and provides object materialization on top of our queries. This means that instead of getting text-based results, we get back a collection of CLR objects that we can easily work with. The two mains components of the Object Services taxonomy are: ObjectContext, and ObjectQuery<T>ObjectContext is equivalent to an EntityConnection, and is what manages our connection to the EDM as well as provides crucial services for working with our data.ObjectQuery is equivalent to an EntityCommand and represents a single query executed against our EDM, that is manifested back as strongly-typed objects. Object Services allows you to write queries using two flavors: Entity SQL LINQ To Entities The same Entity SQL queries you would write using Entity Client can be leveraged with Object Services, but with the added benefits you get with the higher abstraction level (i.e. object materialization). While Entity SQL is great for scenarios that require a dynamic query, or greater control over your query’s shape, you’re still working with a string that is error-prone. In addition to Entity SQL, Object Services allows you to write your queries against it in LINQ which provides you with strong-typing, error-checking, and a higher level of abstraction from Entity SQL. If you are already familiar with LINQ, then you don’t have to master Entity SQL in order to query an EDM, because LINQ To Entities will make the translation for you. In addition to object materialization, object services provides you with other benefits/services: Unit of work Your Object Context represents your unit of work, which aggregates all changes made to all entities attached/contained in it, so that when you want to push those changes back to the server, you can do so in a single batch. Identity tracking The ObjectContext keeps track of the entities you’ve queried for by key, so that if you later request the same entity (by key), using the same ObjectContext instance, it will return you the instance it already has instead of re-hitting the database. Eager/explicit loading The Entity Framework doesn’t pre-load any relationship properties for you. If you want to query an entity as well as some of it’s related entities, you’ll need to explicitly request that by performing a “span” using the Include method of the ObjectQuery<T> class. Alternatively you can call the Load method on your entity’s relationship property.
  • Estimated Time: 10 minutesDescription: Building upon where we left off at the last demo, show how to make Entity SQL queries using Object Services, retrieving back objects instead of text-based results. Then show how using LINQ To Entities can make querying your EDM even simpler and more intuitive. Show an example of identity tracking, eager loading, and explicit loading. Show some simple examples of modifying data and then saving it back to the database.
  • Estimated Time: 3 minutesTalking Points: This diagram helps to illustrate how each of the Entity Framework’s query options relate to each other. At the core of it all is the database-specific provider. This layer is what translates the query into the SQL flavor required for the underlying data source. Above that is the Entity Client API, which takes the Entity Framework query and passes in down to the database specific provider. If you want to use the Entity Client API directly, you see that you’re only query option is Entity SQL, and because it sits below Object Services, you don’t get any of its benefits. If you want to materialize your queries as objects, and get things like change tracking, identity mapping, relationship loading, etc. then you would use object services, that delegates its queries down to the Entity Client layer. When using Object Services you can leverage both Entity SQL and LINQ to make your queries.
  • Table per type – classic inheritance where separate table contains additional propertiesTable per hierarchy – many types contained in one table and used an indicator flag to indicate the type, table may contain null columns when they have no relevance to type. Situation may occur when table had been de-normalized. Can create many sub-types based on table.Table per concrete type – all information for sub-type in a separate table, e.g. discontinued product information used for reference
  • Estimated Time: 4 minutesTalking Points: Let’s briefly take a look at some common scenarios that services apply. If you develop an AJAX application, the client requests a page and the server returns HTML and JavaScript. At that point all communication happens between the client (JavaScript) and the server. This situation will typically call for a set of services on the server that the client can call using AJAX. In this scenario, the service required for client-server communication is largely data centric, and could look similar to the example we saw in the previous slide [Advance Animation] In a Silverlight application, the server returns the compiled Silverlight app, which then runs on the client’s machine. At that point any client-server communication is done with services. A lot of the services required by the client might be data-centric, at which point we’re in the same situation as we saw in the previous slide [Advance Animation] If you’re creating an online service that is meant to provide data over the cloud, then you’re creating nothing but data access logic, so we’re looking at the same scenario as before [Advance Animation] Finally if you’re creating a mashup, your server returns the UI of the mashup itself, which in turn contains logic for communicating with the data feeds that you’re mashing up. There are many other scenarios that require the use of services, but these exemplify enough the need for services that are largely data-centric. Keep in mind, that there are plenty of scenarios where service functionality that is operational in nature and not data-centric, is also typically required. But in many cases in these scenarios, the common need is data.
  • Estimated Time: 4 minutesTalking Points: Today is we wanted to make a web service using the .NET stack, we could use ASMX or WCF. Both options are great and provide there own level of flexibility and ease-of-use, based on your own familiarity. Imagine we create a service, and initially our service’s purpose is to return a specific customer from a data store [Advance Animation] We simply create a GetCustomer method on our service, and we’re good to go. We later realize that we need to be able to retrieve a list of all customers as well [Advance Animation] We add a GetCustomers method that retrieves all customers, easy enough. We realize that we’ll also have a need to retrieve customers, sorted by a specific field [Advance Animation] We add an overloaded version of GetCustomers that takes an order column. While our service’s functionality is increasing, so is its size. Now we realize that we need to be able to specify the sort direction of the ordered customers we retrieve [Advance Animation] Yet another overloaded version of our GetCustomers method is created. While being able to retrieve all customers is great, the amount of data being transported is too much, so we need to implement a paging mechanism [Advance Animation] Great, now we have paging, and another GetCustomers overloaded. Then we realize we need to be able to apply an arbitrary filter criteria to the method, so we add yet another overload [Advance Animation] So now we have created six methods on our service just to retrieve customer data with ordering, paging, and filtering. What if we later needed address data, and orders made by customers, etc. The amount of code needed to write data access code grows exponentially. Even further, we have only discussed the read operations. What if we later need to have insert, update, and delete methods for customers on our service? Yet more methods added, and more boilerplate code written.
  • Representational State Transfer (REST) is an architectural pattern used in the design of services. REST is about the way in which you expose and make available to callers the contract of the service. REST, therefore, is opposed to SOAP. ADO.NET Data Services’ RESTful interface uses a common URL syntax that clients can learn and leverage across all data services This makes it easy to consume new data services once you’re familiar with the syntax
  • It’s important to note that the “Data” in “Data Services” isn’t referring to a database. A data service is meant to expose data, of any kind over the web, in a standard, and easily consumable fashion. A data service is capable of exposing any object model that contains public properties of type IQueryable<T>. This criteria matches LINQ To SQL, and the Entity Framework, but can just as easily fit a custom object model. Data services implements the Atom Publishing Protocol (AtomPub or APP): Maps HTTP verbs to CRUD operations: GET = Read POST = Create PUT = UpdateDELETE = Delete Exposes the data in the form of Atom feeds and entries
  • http://localhost/AWDataServices/WebDataService.svc/$metadatahttp://localhost/AWDataServices/WebDataService.svc/Producthttp://localhost/AWDataServices/WebDataService.svc/Product(324)http://localhost/AWDataServices/WebDataService.svc/Product(324)/Namehttp://localhost/AWDataServices/WebDataService.svc/Product(324)/Name/$valuehttp://localhost/AWDataServices/WebDataService.svc/ProductSubcategory(2)/Producthttp://localhost/AWDataServices/WebDataService.svc/ProductSubcategory(2)/Product(789)/Namehttp://localhost/AWDataServices/WebDataService.svc/Product?$orderby=Namehttp://localhost/AWDataServices/WebDataService.svc/Product?$filter=Color%20eq%20'Black’http://localhost/AWDataServices/WebDataService.svc/Product?$top=10&$skip=30http://localhost/AWDataServices/WebDataService.svc/ProductSubcategory?$expand=Product
  • Estimated Time: 2 minutesTalking Points: While working with a data service in a browser is great, that doesn’t exactly help accent a client application very much. Because data services have a RESTful interface, you could program against use them using any HTTP stack, such as the HttpWebRequest class in .NET.HttpWebRequest doesn’t offer the rich data platform client functionality that developers might expect, which is why ADO.NET Data Services provides a set of client APIs for working with data services in a more intuitive way: There is a client API for .NET applications as well as Silverlight applications. These allow you to consume a data service from within managed code. There is a new data source control that allows the consumption of a data service using the familiar data source paradigm with an ASP.NET application, that can be easily connected to a GridView, ListView, FormView, or DetailsView. Finally there is a client-side API that allows data service consumption using the ASP.NET AJAX library. With these four client options, you are able to consume a data service from within any .NET application, regardless of the environment.
  • Estimated Time: 3 minutesTalking Points: When using the .NET client API, the DataServiceContext class represents your connection to the data service. The DataServiceContext class provides a lot of functionality around consuming a data service. The arguable two most notable features it provides are: An abstraction layer over the HTTP requests made to the service Object materialization Writing the code required to communicate with a data service using the HttpWebRequest class wouldn’t be that hard, but it would quickly get pretty verbose and time-consuming. Being able to use the DataServiceContext class saves you the effort of working at the HTTP-level completely (there are hooks that let you peer into it if you need to) and allows you to simply request the data you want and let the API handle the plumbing for you. As we saw in our previous examples, the data service returns data in AtomPub format by default, which is great, but would be a pain to have to manually parse in our client application. Fortunately the DataServiceContext class provides full object materialization which translates the returned AtomPub content into CLR objects that we can easily use. The best part about the DataServiceContext’s object materialization is that is doesn’t require the client-side model to match the service-side model at all. As the diagram illustrates, the two-models are completely independent and can to a large degree evolve independently.
  • Talking Points: ASP.NET Routing allows you to define a set of routes that dictate the URL templates your application can respond to, and map them to a handler that can direct the request at the proper resource (i.e. page, controller action method, etc) You can define your routes using both static URLs (/Products/Edit/23) as well as parameterized (/Blog/{year}/{month} /{day}) It is the route handler that is responsible for translating the requested route into an actionable resource than can respond to the request Once you’ve defined your custom route table, you can essentially use it to generate your application’s sitemap. If you know the resource you want, and the parameters it needs, then the ASP.NET Routing engine can generate the proper URL for you based on your route definitions Both ASP.NET MVC and ASP.NET Dynamic Data leverage ASP.NET Routing to enable their custom URL schemes
  • Talking Points: ASP.NET Dynamic Data allows you to specify a data model (EDM, LINQ To SQL, etc) and have an entirely scaffolded web application generated Complete with pages for viewing, adding, editing, and deleting records from each scaffolded entity in your underlying model Each page in the generated application is AJAX-enabled to provide a rich user-experience Each list page provides filtering based on the entity’s foreign-key relationships Your data model can be extended with the new data annotation attributes to add more semantic value to it Add validation to properties within your entity objects: regex, range, required, string length Add metadata to your entities: display column, sort column, display format Define custom data types and associate custom UI templates to entity properties When you create a Dynamic Data application, you get a collection of page templates and field templates, that are used to display your application. Each of these templates can be modified to suit your needs. New templates can also be created. Aside from creating a full-blown dynamic data web application, you can also leverage the dynamic behavior in an existing ASP.NET application, using the standard GridView, ListView, FormView controls you’re already familiar with.
  • Dynamic Data Entities Web ApplicationAdd EDM for Northwind databaseCategoriesProductsSuppliersAdd Data Field Templates
  • Add Dynamic Data Field to Field Templates – IntegerSliderDelete ReadOnly templateAdd UIHint to DataFieldTemplate
  • Estimated Time: 1 minuteTalking Points: In addition to brand new functionality, .NET 3.5 SP1 adds a lot of feature enhancements to existing technologies (listed).
  • As the .NET framework grows and matures, its file size also increases. This large download requirement often poses a problem for clients that don’t have the framework installed. The .NET Framework Client Profile is a new subset of the entire .NET Framework that includes only client-specific assemblies (i.e. WinForms, WPF) and doesn’t contain any of the server-specific assemblies (i.e. LINQ To SQL, Windows Workflow Foundation). The result is a reduced download footprint requirement for client applications that aren’t going to need the extra assemblies anyways. When an application is specifically targetting the .NET Framework Client Profile, Visual Studio will provide compile errors when the application’s code is attempting to use a type that isn’t within an included assembly. The size of the .NET Framework Client Profile is 26mb. A client machine that has the .NET Framework Client Profile can later upgrade to the full version of the .NET Framework if needed.
  • Transcript

    • 1. .NET 3.5 Enhancements (SP1)
      Dave Allen
      ISV Application Architect
      Developer and Platform Group
      Microsoft UK
    • 2. Agenda
      ADO.NET Entity Framework
      ADO.NET Data Services
      ASP.NET Routing
      ASP.NET Dynamic Data
    • 3. ADO.NET Entity Framework
      Another data access technology!?!
      Not designed to replace what has gone before
      Addresses the OOP versus Relational problem
      OOP very well established
      Relational have been around even longer
      Bridging the gap has mostly been a manual task
      Some 3rd party solutions, core problem remains
      Objects != Relational Data
      Fundamental problem is that relational data and objects in a programming language are NOT the same!
      They have different semantics, languages, etc.
      But both are still needed in most applications
    • 4. ADO.NET Entity Framework
      Entity Data Model
      Models Entities and relationships between those Entities
      How does it bridge the gap between OOP and Relational
      Common type system
      Inheritance
      Complex types
      EDM is scoped to just modeling design of application data
      Entity Framework
      Provides services for consuming an EDM
      Object Services
      Entity Client (EntityConnection, EntityDataReader, etc.)
      Entity SQL
      LINQ To Entities
      Provider model for 3rd party databases
    • 5. Entity Data Model
      Application model
      Mapped to a persistence store
      Comprised of three layers:
      Conceptual (CSDL)
      Mapping (MSL)
      Storage (SSDL)
      Database agnostic
      Not compiled
      Embed as a resource
      Store externally
      Entity Data Model
      Conceptual
      Mapping
      Storage
    • 6. Demo
      Entity Data Model
    • 7. Entity Framework
      EDM consumption options:
      Entity Client
      Entity SQL
      Object Services
      Entity SQL
      LINQ To Entities
    • 8. Entity Client
      Familiar ADO.NET object model:
      EntityCommand
      EntityConnection
      EntityDataReader
      Entity Parameter
      EntityTransaction
      Text-based results
      Read-only
      Uses Entity SQL
    • 9. Entity SQL
      • SQL-like query language
      • 10. Targets conceptual model
      • 11. Database agnostic
      T-SQL
      Entity SQL
    • 12. Demo
      Entity Client
    • 13. Object Services
      Object materialized queries
      ObjectContext
      ObjectQuery<T>
      Built on top of Entity Client
      Two query options:
      Entity SQL
      LINQ
      Runtime services:
      Unit of work
      Identity tracking
      Eager/explicit loading
    • 14. Demo
      Object Services
    • 15. Entity Framework – Service Stack
      LINQ To Entities
      Entity SQL
      Object Services
      Entity Client
      ADO.NET Provider
    • 16. Entity Framework features
      Many to many relationships
      Join tables ignored by designer in EDM
      Side-effect, relationships cannot contain data
      LINQ supports this via the aggregate functions
      Inheritance
      Allows Entities to be specialized
      Maps to CLR inheritance
      Fully supported in queries
      3 types of inheritance
      Table per type
      Table per hierarchy
      Table per concrete type
    • 17. Entity Framework features (2)
      Entity splitting
      Single entity split across multiple tables, something you may do with very large tables
      Stored procedures
      Most asked question about EF
      Fully supported for CUD, map CUD functions to SPs
      Mainly supported for queries, but doesn’t support composable queries, dynamic SQL within SPs
      No metadata available at design-time
      Working against principles of EF
      Don’t use EF if you do this
      Consider using TVF instead of SPs
    • 18. LINQ to SQL or Entity Framework
      The case for LINQ to SQL
      Use an ORM solution where database is 1:1 with Object Model
      Use an ORM solution with inheritance hierarchies that are stored in a single table
      Use POCO instead of using generated classes or deriving from a base class or implementing an interface
      Leverage LINQ as the way to write queries
      Use an ORM solution, but want something that is very performant and where optimization can be achieved, where necessary, through stored procedures
    • 19. LINQ to SQL or Entity Framework (2)
      The case for LINQ to Entities
      Write applications that can target different database engines in addition to SQL Server
      Define domain models for applications and use them as the basis for the persistence layer
      Use an ORM solution where classes may be 1:1 with the database or may have a different structure from the database schema
      Use an ORM solution with inheritance that may have alternative storage schemes (single table for the hierarchy, single table for each class, single table for all data related to specific type)
      Leverage LINQ as the way to write queries and have the query work in a database vendor agnostic manner
      Use an ORM solution, but want something that is very performant and where optimization can be achieved, where necessary, through stored procedures
    • 20. Data Service over HTTP
      HTML + JavaScript
      DLL + XAML
      Mashup UI
      Data (XML, etc)
      Data (XML, etc)
      Data (XML, etc)
      Data Feeds
      AJAX Applications
      Silverlight Applications
      Online Services
      Mashups
    • 21. Data Services today
      Web Service (ASMX, WCF)
      1) GetCustomer(int id)
      2) GetCustomers()
      3) GetCustomers(string orderBy)
      4) GetCustomers(string orderBy, string sortDirection)
      5) GetCustomers(string orderBy, string sortDirection,
      int offset, int count)
      6) GetCustomers(string orderBy, string sortDirection,
      int offset, int count,
      string filter, string filterValue)
    • 22. ADO.NET Data Services
      Data publishing service using a RESTful interface
      Just uses HTTP
      Therefore is able to use existing authentication mechanisms, and other infrastructure components such as caching and proxies
      Uniform URL Syntax
      Every piece of information is addressable
      Predictable and flexible URL syntax
      Multiple representations
      ATOM
      JSON
      POX
    • 23. ADO.NET Data Services (2)
      Exposes an object model (not a database) over the web
      Entity Data Model – ADO.NET DS designed to work with EDM
      LINQ To SQL model, read-only
      Custom IQueryable<T> provider
      Operation semantics, mapping of HTTP verbs for CRUD operations
      GET – retrieve resource
      POST – create a resource
      PUT – update a resource
      DELETE – delete a resource
    • 24. URL Conventions
      Addressing entities and sets
      Presentation options
    • 25. Filters
      Logical operators
      and, or , asc, desc, eq, ne, true, false, gt, ge, lt, le, not, null
      Arithmetic operators
      add, sub, div, mul, mod
      String functions
      endswith, indexof, replace, startswith, tolower, toupper, trim, substring, substringof, concat, length
      Date functions
      year, month, day, hour, minute, second
      Math functions
      round, floor, ceiling
      Type functions
      Is, Cast
    • 26. Demo
      ADO.NET Data Services – Adventure Works
    • 27. Securing and Customizing Data Services
      Visibility
      Control visibility per container
      Read, Query, and Write options
      Authentication
      Integrates with the hosting environment
      ASP.NET, WCF, or Custom authentication module
      Interceptors
      Execute before HTTP GET/PUT/POST/DELETE
      Enable validation, custom row-level security
      Maintain the REST interface
      Service operations
      Allow you to inject methods into URI if you need to
    • 28. Clients
      Data Service
    • 29. ASP.NET AJAX Client
      Server
      Client
      Data
      Service
      Sys.Data.
      DataService
      HTTP
      Data
      Model
      JSON
    • 30. ASP.NET AJAX Client
      Sys.Data.ActionSequence
      Sys.Data.DataService
      Sys.Data.QueryBuilder
    • 31. .NET Client
      Server
      Client
      Data
      Service
      Data
      Service
      Context
      HTTP
      Data
      Model
      Object
      Model
    • 32. Demo
      Silverlight 2.0 Client - Northwind
    • 33. Operation Batching
      Without batching
      Data
      Service
      Context
      Data
      Service
      POST
      PUT
      POST
      DELETE
      DELETE
      5 server hits
      Operations:
      Add Entity #1
      Update Entity
      Add Entity #2
      Delete Entity #1
      Delete Entity #2
    • 34. Operation Batching
      With batching
      Data
      Service
      Context
      Data
      Service
      POST /$batch
      1 server hit
      Operations:
      Add Entity
      Update Entity
      Add Entity #2
      Delete Entity
      Delete Entity #2
    • 35. Operation Batching
      Without batching
      Data
      Service
      Context
      Data
      Service
      GET
      GET
      GET
      3 server hits
      Operations:
      Get Entity #1
      Get Entity #2
      Get Entity #3
    • 36. Operation Batching
      With batching
      Data
      Service
      Context
      Data
      Service
      GET /$batch
      1 server hit
      Operations:
      Get Entity #1
      Get Entity #2
      Get Entity #3
    • 37. Demo
      Operation Batching
    • 38. ASP.NET Routing
      Define your application’s URL entry points
      Static (/Products/Edit/23)
      Parameterized (/Blog/{year}/{month} /{day})
      Map these URL templates to route handlers
      Generate URLs based off your defined route table
      Can be leveraged by ASP.NET…
      WebForms
      MVC (using)
      Dynamic Data (using)
    • 39. Demo
      ASP.NET Routing
    • 40. ASP.NET Dynamic Data
      RAD approach to building data driven web apps
      Based on top of object model
      LINQ To SQL
      Entity Data Model
      Data-driven web application ‘scaffolding’
      Uses the power of the underlying schema
      Customizable through templates
      Full CRUD operations
      AJAX-enabled
      Extend the model
      Metadata
      Validation
    • 41. ASP.NET – traditional approach
      Create a data access layer
      ADO.NET (Datasets, Custom Objects, XML, etc.)
      LINQ to SQL
      Created ASP.NET pages
      Add Data Source controls
      Add controls that bind to Data Source controls
      Add validation logic to page
      Issues
      Lots of work up front
      Duplication of validation logic
      DB schema ignored – data validation ends up in UI
      Reuse needs to be thought about – not intuitive
    • 42. ASP.NET – dynamic data approach
      Create a data model
      Entity Framework
      LINQ to SQL
      Generate a Dynamic Data application
      Customize the application
      Model
      Fields
      Pages
      Routes
    • 43. Annotating the model
      Metadata on model controls behavior
      Default metadata inferred from schema
      Data types and relationships
      Required fields, field type, string length, etc.
      Generate a Dynamic Data application
      Add additional metadata
      Validation
      Field labels and descriptions
      Partial methods
    • 44. Demo
      ASP.NET Dynamic Data
    • 45. Field templates
      Fields are rendered using templates
      Implemented as a user control .ascx
      Controls the rendering, data binding, and validation
      Based on the field data type, integer, bool, string, etc.
      Default selection can be overridden
      Default field templates ‘out-of-the-box’
      These can be customized – they are just user controls
      Create new field templates
    • 46. Dynamic Data Controls
      DynamicDataManager
      GridView, DetailsView
      DynamicDataField
      ListView, FormView
      DynamicControl
      LinqDataSource, EntitiesDataSource
      DynamicControlParameter
      DynamicQueryStringParameter
      DynamicValidator
      DynamicFilter, FilterRepeater
    • 47. Demo
      ASP.NET Dynamic Data – Field Templates
    • 48. .NET 3.5 SP1 – What’s been improved
      ASP.NET AJAX
      WCF
      WPF
      WinForms
    • 49. Visual Studio 2008 SP1 – What’s else?
      SQL 2008
      JavaScript formatting and code preferences
      Improved JavaScript Intellisense
      Classic ASP Intellisense/Debugging
      WCF refactoring support (svc/config files)
      .NET Framework Client Profile
      26mb download

    ×