MAGAZINE. IN DIT NUMMER O.A.:

Transcriptie

1 MAGAZINE IN DIT NUMMER O.A.: Implementing KeyValueCoding in Delphi Prism < Designing Recoverable and Restartable SSIS Packages < Green Computing: Sparen door te Delen < Silverlight Web Parts in SharePoint < ADO.NET Entity Framework Overview < Nummer 101 mei 2009 SDN Magazine verschijnt elk kwartaal en is een uitgave van Software Development Network 101 Women in Technology

2 Advertentie Macaw

3 Colofon Uitgave: Software Development Network Zeventiende jaargang No. 101 mei 2009 Bestuur van SDN: Remi Caron, voorzitter Rob Suurland, penningmeester Joop Pecht, secretaris Mark Vroom, vice-voorzitter Redactie: Rob Willemsen Aan dit magazine werd meegewerkt door: Maurice de Beijer, Rolf Craenen, Marcel van Kalken, Stefan Kamphuis, Marcel Meijer, Mirjam van Olst, Johan Parent, Joop Pecht, Sandra de Ridder, Maarten van Stam, Bob Swart, Marianne van Wanrooij, Rob Willemsen en natuurlijk alle auteurs! Voorpagina: v.l.n.r. Sandra de Ridder (UX), Mirjam van Olst (IW) en Marianne van Wanrooij (IW) Foto: Maarten de Meijer Listings: Zie de website voor eventuele source files uit deze uitgave. Vormgeving en opmaak: Reclamebureau Bij Dageraad, Winterswijk Alle rechten voorbehouden. Niets uit deze uitgave mag worden overgenomen op welke wijze dan ook zonder voorafgaande schriftelijke toestemming van SDN. Tenzij anders vermeld zijn artikelen op persoonlijke titel geschreven en verwoorden zij dus niet noodzakelijkerwijs de mening van het bestuur en/of de redactie. Alle in dit magazine genoemde handelsmerken zijn het eigendom van hun respectievelijke eigenaren. Adverteerders Macaw 2 Avanade 12 MI Consultancy 16 Sybase ianywhere (ADS) 19 Aladdin 25 Bergler 26 Microsoft DotNet b.v. 41 Barnsten/Embarcadero 48 VNU 54 Sogeti 67 Bridge Incubation Group b.v. 68 Voorwoord: Women in Technology Dit 1e magazine na nummer 100 is al weer een speciale editie; 1tje waarbij we intern nogal wat gediscussieerd hebben over hoe duidelijk te maken dat dit een bijzondere uitgave is. De uitkomst van al die discussies is bekend: die heb je immers nu in handen. Dat is dus wat ervan terecht gekomen is, van het Women In Technology idee: Zou het niet aardig zijn om 1 magazine compleet te vullen met vrouwelijke input?. Waar ging de discussie dan over, zul je je wellicht afvragen Moeten we dat in een special doen en hoe moet die er dan uitzien? Vooral dus over de vraag of we dit blad als iets heel bijzonders moesten brengen de fysieke vorm van het blad van een A4-rechthoek transformeren in vrouwelijke richting, een blonde omslag met bijzonder make-up/opmaak en de overige ideeën onthoud ik je of juist als iets heel normaals, want dat is wat we eigenlijk zouden willen een werkomgeving waarin het net zo normaal voor mannen als voor vrouwen is om hun inzet te tonen, hun creativiteit te benutten, mooie en nuttige software te bouwen, samen te werken, enz. Uiteindelijk zijn we toch een beetje op een compromis uitgekomen, zoals in ons polderlandje wel (veel) vaker gebeurt, met op de coverfoto die had je toch al gezien, zeker?! - de 3 (!) vrouwelijke SDN-orgo s als een special item. Is dat eigenlijk wel nodig, die speciale aandacht voor dat onderwerp? Als ik het aan mijn vrouwelijke collega s zelf vraag, dan is extra aandacht niet nodig. Maar we zijn het met z n allen eens dat de ICT branche een duf imago heeft. Een wereld voor nerds en geeks. Terwijl het en niet alleen voor meisjes - een interessante keuze kan zijn voor iedereen die creatief bezig wil zijn en oplossingsgericht wil denken en werken, samen wil werken en wil kennisnetwerken, allemaal aspecten die software development met zich meebrengt. Rob Willemsen redacteur van dit blad is Informatica docent in het HBO. Hij gaf aan dat al heeeeeel veel geprobeerd is, en zonder veel succes. Het afgelopen jaar waren bij zijn school ca. 5% meisjes onder de 1e jaarsstudenten, en dat was een stijging van 400% t.o.v. het jaar ervoor. Echt waar! In studierichtingen waarin naast het I-woord (I van Informatica) ook het C-woord (C van Communicatie) voorkomt ligt de deelname van meisjes echt veel hoger: 30% is daar niet ongebruikelijk. Denk je dat dat lukt dan, enkel artikelen van vrouwelijke hand? Het blad heeft niet als doel aan te tonen dat er een kwaliteitsverschil is tussen mannen en vrouwen. Aan de kwaliteit van de al aanwezige vrouwen ligt het niet: dit magazine doet kwalitatief absoluut niet onder voor eerdere edities waarin de kwantitatieve! - verhouding tussen de sexes altijd veel dichter in de buurt lag van de werkelijkheid binnen de ICT-wereld. Dat er competentieverschillen zijn, moge duidelijk zijn. Dit komt de samenwerking binnen projecten alleen maar ten goede en is ook een veelgehoorde reden waarom bedrijven graag meer vrouwen aan zouden willen nemen voor technische functies. En ja het lukte! Ok, let s give it a try then! En zie hier vanuit alle networks zijn er artikelen aangeleverd die geschreven zijn door vrouwen, werkzaam in de ICT-wereld! Het kan dus! Willen we dingen (laten) veranderen, dan moeten we o.a. bij de vroege jeugd beginnen en rolmodellen kunnen daar een positieve invloed bij hebben. Dit ene SDN-magazine zal de verhoudingen op middelbare, hogere en wetenschappelijke onderwijsinstellingen heus niet door elkaar schudden, maar alle beetjes kunnen helpen. Daarnaast heb ik (toch wel goede) hoop dat software voor de huidige jeugd die de 1e lichting digital natives vormen dusdanig gemeengoed is en ook uitermate verbonden met hun communicatie en samenwerking, dat automatisch meer jeugdigen, jongens én meisjes, geïnteresseerd zullen raken in hoe je dat soort spul nu maakt en ook hoe je daarvoor nieuwe toepassingen kunt bedenken.laten wij in ieder geval proberen zo veel mogelijk voorbeelden te stellen, en hierbij dus onze inbreng! Wat vind je dan zoal in dit WIT-magazine? Een stuk of 13 artikelen van dameshand, goed voor zo n pagina s leesvoer. De start van een nieuwe komische column DevTweet door Marianne van Wanrooij & Sander Hoogendoorn, waarvan de inhoud o.a. via discussie op Twitter gevoed wordt, en de reguliere columns de enige male-only ingrediënten in dit magazine. Adverteren? Informatie over adverteren en de advertentietarieven kunt u vinden op onder de rubriek Magazine. Marianne van Wanrooij Marianne.vanWanrooij@sdn.nl magazine voor software development 3

4 Inhoud 03 Voorwoord: Women in Technology Marianne van Wanrooij 04 Inhoudsopgave 05 Implementing KeyValueCoding in Delphi Prism Joanna Carter 08 Agenda 09 What s New in WCF 4.0? Michèle Leroux Bustamante 13 Designing Recoverable and Restartable SSIS Packages Jessica M. Moss 17 Green Computing: Sparen door te Delen Astrid Hackenberg 20 Using Windows Presentation Foundation and Line-of-Business Data in Microsoft Office Clients Beth Massi 27 Silverlight Web Parts in SharePoint Mirjam van Olst SDN EVENT 26 juni 2009 Hotel Houten Houten 36 HP NonStop: 30 Jaar Ontwikkeling in NonStop Transactieverwerking Frida Robben 38 ADO.NET Entity Framework Overview Julia Lerman 42 DevTweet Marianne van Wanrooij en Sander Hoogendoorn 43 The WebHub Way of Thinking Ann Lynnworth 49 ASP.NET onder de Motorkap: De performance van ASP.NET is slecht Michiel van Otegem 50 Requirements Management Houdt de Kikkers in de Kruiwagen Frédèrique Harmsze 55 Business Intelligence: Theorie en Praktijk Liesbeth Smits 58 Creating Help Systems with Help & Manual Loy Anderson 63 Interesting things: Trojan Rigidity Sander Hoogendoorn 64 Using jquery UI in DotNetNuke Modules Sarah Darkis

5 DELPHI Joanna Carter Implementing KeyValueCoding in Delphi Prism Introduction If you ve ever used.net bindings to connect UI widgets to properties of objects in a Win- Forms project, this article will demonstrate how to design Delphi Prism classes that can use Cocoa bindings to achieve the same ease of form design when writing an application for OS X. One of the nice features available to developers using the Cocoa frameworks, is the concept of Key-Value coding. The basic premise of this feature is to implement the Observer design pattern, allowing one object to respond to changes to the properties of another. However, once implemented, another benefit becomes available; Cocoa bindings use the Key-Value pattern to support, amongst other things, the connection of UI controls to properties of business objects, allowing the UI control to be updated automatically when the property of the object changes and, also, the property of the object to be set when a new value is entered into the UI control. Whereas, with simple Key-Value coding, a Controller can listen to changes on an object and then interpret those changes into messages to a UI control, bindings completely remove the need for any "glue code" in between the object being observed and the UI controls that are displaying the values of an object's properties. This example uses the Monobjc bridge libraries, so you will need to ensure that these are installed before proceeding any further Creating the test project This example uses the Monobjc bridge libraries, so you will need to ensure that these are installed before proceeding any further. Start by ensuring that your Windows VM is available, opening Delphi Prism and creating a new Monobjc application called KVOExample. If you haven't installed Monobjc in a location the project can find on its own you may have to re-establish the References section of the project to point to your installed location for Monobjc. A value-key coding compliant class The first thing we need to do is to define the class for the object whose properties we wish to display on a form. So, add a new class to the project, called Customer. namespace KVOExample.Interface.nib; interface uses Monobjc.*; type [ObjectiveCClass("Customer")] Customer = public class(nsobject) private fname: NSString; protected public [ObjectiveCMessage("name")] method getname: NSString; [ObjectiveCMessage("setName:")] method setname(value: NSString); property Name: NSString read getname write setname; end; As you will see, it is necessary to do slightly more coding than for a standard Delphi Prism class if we want this class to be usable by the ObjectiveC runtime. 1. The class has to derive from NSObject (at least). 2. The class has to be marked with the ObjectiveCClass Attribute. 3. Any property that is to be involved in Key-Value coding has to be of a type that ObjectiveC can recognise. 4. Properties must be represented by two public methods: a getter and a setter. 5. Property getter and setter methods can be named as desired but they must also be labelled with an ObjectiveCMessage attribute which follows the naming convention that ObjectiveC expects: "<propertyname>" and "set<propertyname>". magazine voor software development 5

6 DELPHI Of course, as far as ObjectiveC is concerned, you need not have a property declaration at all; that is included for ease of coding from other Delphi Prism classes. We shall not be using the toolbar, so that can be removed and one Button, one Text Field and two Labels can be added, to give us a form that looks like this : method Customer.getName: NSString; begin result := fname; end; The getter method is just a simple return of the private field's value. method Customer.setName(value: NSString); begin WillChangeValueForKey("name"); fname := value; DidChangeValueForKey("name"); end; Fig. 3: The completed form ControllerInspector Now, switch to the ApplicationController icon in the NIB window and add the Actions and Outlets you see in the next image : However, the setter method has to contain calls to the two methods of NSObject that will, in turn, notify those objects that are registered as having an interest in changes to instances of this class. Creating the editing form Now we have created a business class, we can focus attention on creating a form on which we can edit an instance of that class. On the OS X side of things, open Interface Builder, navigate to the Interface NIB file within the project directory and open it. You should see something like this : Fig. 1: The new Nib file If it is not already showing, double-clicking on the Window icon will open the main form, which should look like this : Fig. 4: Created Actions and Outlets In order for these Actions and Outlets to appear in the Delphi Prism class declaration, you will need to connect the button to the setcutomername action, the nameedit outlet to the Text Field and the name- Label outlet to the right hand of the two Labels on the form. Once these changes are made, we need to save the NIB and that should complete our work in Interface Builder. Fig. 2: The new form Completing the controller class Changing back to Visual Studio, we now need to make our Delphi Prism project aware of the changes that have been made to the NIB which we have just edited. In the Solution Explorer, expand the Interface.nib node until you can see the designable.nib node. Right-clicking on this node should display a menu which includes the entry "Run Custom Tool"; clicking on this item will update the designable.pas source file to include the changes we have just made to the NIB in Interface Builder. 6 MAGAZINE

7 DELPHI In designable.pas, you should now see a class declaration that looks like this : [ObjectiveCClass] ApplicationController = public partial class(nsobject) public var [ObjectiveCField] nameedit: NSTextField; var [ObjectiveCField] namelabel: NSTextField; [ObjectiveCMessage('setCustomerName:')] method setcustomername(sender: NSObject); partial; empty; end; Having updated the ApplicationController class to this stage, we can now switch to the ApplicationController.pas file in the solution, and complete any code required to link up the form to an instance of our Customer class. type ApplicationController = public partial class(monobjc.cocoa.nsobject) private fcustomer: Customer; method AfterConstruction; partial; protected public method AwakeFromNib; partial; method setcustomername(sender: NSObject); partial; end; As you can see, the setcustomername method is now implemented in the separate ApplicationController.pas unit but, since we need the controller to hold an instance of our Customer class, we also need to add a private field and to implement the awakefromnib method to hook up the controls to the Name property of our Customer object. changes. In ObjectiveC, the method signature would be observevalueforkeypath:ofobject:change:context: which can be defined in Delphi Prism like this : method ApplicationController. observevalueforkeypathofobjectchangecontext( keypath: NSString; object: NSObject; change: NSDictionary; context: NSObject); begin The "change" NSDictionary parameter contains one or more key-value pairs, depending on the type of change that has occurred in the object that is being observed; in this example, all we are interested in is whether the value of any property of the observed object has changed. Cocoa defines a set of string constants as part of the NSKeyValueObserving framework Cocoa defines a set of string constants as part of the NSKeyValue- Observing framework; these are replicated, in Mono, as the NSKey- ValueObserving static class which contains static fields for the constants. In this example, we are interested in retrieving the NSKey- ValueObserving.NSKeyValueChangeKindKey entry in the change dictionary, in order to ascertain the kind of change that has occurred to the observed object. The value held in the NSKeyValueObserving.NSKeyValueChange- KindKey entry in the dictionary is of the NSKeyValueChange enum type so, because direct casting of ObjectiveC types is not possible in Delphi Prism, we have to carefully convert the Id type of the value returned from the dictionary entry to the NSValueChange type. method ApplicationController.AfterConstruction; begin fcustomer := new Customer(); end; We could use Cocoa Bindings to connect both the Text Field and the Label to the Customer but, since the Label only needs to observe changes to the Customer and not make them, we will only use KVO to update the Label. var changekindasid: Id := change[nskeyvalueobserving.nskeyvaluechangekindkey]; The Id type is, essentially, an untyped pointer so, first, we have to convert the value to an NSNumber using the CastTo<T> generic method that is a part of the Id class in Monobjc. var changekindasnsnumber: NSNumber := changekindasid.castto<nsnumber>(); method ApplicationController.AwakeFromNib; begin First, we will use Cocoa Binding to connect the Text Field : nameedit.bindtoobjectwithkeypathoptions( "value", fcustomer, "name", nil); But, for the Label, we need to make this ApplicationController the observer for the Name property of the Customer object : fcustomer.addobserverforkeypathoptionscontext( self, "name", NSKeyValueObservingOptions.NSKeyValueObservingOptionNew, nil); end; Implementing a KVO handler method Having told the Customer to tell us when its Name property changes, we need to provide a method that KVO can call when the property Next, because we want to compare this value to a member of an enum, we need to further convert this NSNumber value to the appropriate member of the NSKeyValueChange enum. var changekind: NSKeyValueChange := NSKeyValueChange(changeKindAsNSNumber.UnsignedIntValue); There is no direct cast from an NSNumber to an enum so, instead, we have to cast the unsigned integer value of the NSNumber instance, obtained by using the UnsignedIntValue method of the NSNumber class. Finally, we can compare the value, obtained from the dictionary, with the NSKeyValueChange.NSKeyValueChangeSetting enum value that will tell us if this notification is the result of a change to the value of a property to which we want to react. if changekind = NSKeyValueChange.NSKeyValueChangeSetting then begin Having ascertained that this notification is for a value change, we can magazine voor software development 7

8 DELPHI now determine which property has changed, simply by checking the value of the keypath parameter. if keypath = "name" then Now that we know that there was a value change to the "name" property of the object we are observing, we can obtain the new value by reading it from the NSKeyValueObserving.NSKeyValueChangeNewKey entry in the dictionary. Conclusion Cocoa UI controls can be connected to properties of objects by, either, Cocoa Bindings or Key-Value Observing. This article demonstrated how to create an example project which used Cocoa Bindings to connect a Text Field, and KVO to connect a Label, to the same property of an object, prompting multiple updates to different controls from the same property of an object. label.objectvalue := change[nskeyvalueobserving.nskeyvaluechangenewkey]; end; end; One last thing Finally, we can respond to the button press by setting the Customer.Name to a fixed value: method ApplicationController.setCustomerName( sender:nsobject); begin fcustomer.name := "CodeGear"; end; Putting it to the test Having created all the necessary code for this example, all that is left is to build the application in Visual Studio, find the KVOExample.app file produced and run it. Clicking on the button will set the Customer Name to "CodeGear". Editing the value in the Text Field should set the Name property on the Customer, thus triggering an update of the right-hand Label on the form. Joanna Carter Joanna works as a consultant software engineer, specialising in OO architecture analysis and design, troubleshooting and debugging. She has worked in the UK and Europe and is a regular speaker and author for the UK Developers Group and has also spoken at the SDN conference. Most of her articles/presentations have been on OO architecture and coding, design patterns and refactoring. She has also held OO masterclasses in the UK and US. She has developed an Object Persistence Framework for use with Delphi and C#, Delphi and C# versions of the Model View Presenter framework and has hosted Birds of a Feather sessions on these subjects at BorCon on at least two occasions. Joanna is presently working at writing applications for OS X in both ObjectiveC and Delphi Prism. When she is not tied to a computer, she can be found doing some serious photography using anything from 4x5 field cameras to state of the art digital SLRs. AGENDA 2009 Microsoft DevDays 2009, Den Haag mei SDN Event - Hotel Houten, Houten juni SDN Magazine Nr augustus EKON, Mainz oktober SDN: Software Development Conference 2009 Papendal, Arnhem oktober TechEd Developer EMEA 2009, Berlijn november Microsoft PDC, Los Angeles november SDN Magazine Nr november Genoemde data onder voorbehoud 8 MAGAZINE

9 .NET Michèle Leroux Bustamante What s New in WCF 4.0? An early look at forthcoming WCF features The.NET Framework 4.0 will be released with Visual Studio bringing with it a plethora of new WCF features. WCF 4.0 will solve many pain points related to configuration, tracing and diagnostics, serialization and messaging. In addition this release will include exciting new enterprise-ready features such as service discovery and routing, and when combined with the power of WF 4.0 Workflow Services will greatly simplify how developers incorporate asynchronous programming models to offset expensive IO-intensive operations and improve overall application performance and throughput. In this article I will provide a high level summary of features we know today will be released with WCF to provide you with a well-rounded view of the forthcoming release. Simplified configuration One of the major pain-points experienced by WCF developers is configuration. In WCF 4.0 we can look forward to a significant improvement in this area through configuration defaults, behavior inheritance, and implicit endpoints. Collectively these features can yield a truly configuration-free experience when you host your WCF services. The idea is that you provide better binding configuration and behavior defaults for your specific application s requirements, and the runtime picks up those defaults when it initializes the ServiceHost. Listing 1 illustrates providing default settings for WS2007HttpBinding and several behavior defaults. They are noted as defaults by using an empty string ( ) for the binding and behavior name. <bindings> <ws2007httpbinding> <binding name="" maxreceivedmessagesize=" " > <readerquotas maxarraylength=" " maxstringcontentlength="50000"/> <security mode="message"> <message clientcredentialtype="username" negotiateservicecredential="false" establishsecuritycontext="false" /> </security> </binding> </ws2007httpbinding> </bindings> <behaviors> <servicebehaviors> <behavior name=""> <servicemetadata httpgetenabled="true"/> <servicecredentials> <usernameauthentication usernamepasswordvalidationmode= "MembershipProvider"/> </servicecredentials> <serviceauthorization principalpermissionmode="useaspnetroles" /> <servicethrottling maxconcurrentcalls="30" maxconcurrentsessions="1000"/> </behavior> </servicebehaviors> </behaviors> Listing 1: Binding and behavior defaults in WCF4.0 When the ServiceHost is initialized, an endpoint will be automatically created for each contract implemented by the service type - for each base address provided. When you combine this behavior with default binding configurations and behavior settings, configuration-free hosting actually seems plausible. Serialization enhancements The new DataContractResolver will provide new extensibility hooks useful for customizing CLR type mapping for the DataContractSerializer. This can be useful for simple overrides such as altering the name and namespace for CLR types written to the wire, for overriding which CLR types are involved in serialization, and for dynamically managing known types. Queued Messaging ReceiveContext In order to guarantee exactly once delivery of messages from a queue in Microsoft Message Queuing (MSMQ) you must work with transactional queues and the WCF service operation must participate in the playback transaction. If an exception is thrown while processing the message, the service can guarantee the message doesn t get lost by returning it to the queue - either the originating queue, the dead letter queue or a poison message queue, depending on configuration and MSMQ versions. This is quite useful, but has limitations in that there is no way to ensure that the same service processes the failed message the next time it is pulled from the queue, not to mention that transactions are expensive. WCF 4.0 introduces ReceiveContext as an alternative technique for processing queued messages. The thrust of this new technique is that the message is not pulled from the queue until the message is successfully processed by the service. A ReceiveContext is associated with the message once it is peeked by a service and if an exception is thrown and the message cannot be completed, it remains in the queue but can also remain locked by that particular service to retry processing. This reduces overhead since the message need not be transmitted over the network again to another service. ReceiveContext provides a way to explicitly complete the message so that it can be removed from the queue on success. ReceiveContext guarantees at least once delivery when used without transactions, and when composed with transactions it guarantees exactly once delivery with performance benefits. magazine voor software development 9

10 .NET Web programming Since the release of.net 3.5 it is much easier to build WCF services that bypass SOAP processing requirements including Plain-Old-XML (POX), Java Script Object Notation (JSON) and Representational State Transfer (REST) - the latter of which is an architectural approach for designing POX or JSON services. These techniques fall under the web programming model for WCF services. Microsoft also released the WCF REST Starter Kit which considerably improves productivity when building services for this web programming model. The WCF REST Starter Kit includes the following: Microsoft also released the WCF REST Starter Kit Many Visual Studio templates for the most common scenarios for POX, REST and Atom/Pub. New features to support better error reporting to the browser. Supporting types are WebProtocolException and new behaviors installed with WebServiceHost2 and WebServiceHost2Factory. A much needed extensibility hook for HTTP requests through RequestInterceptor. The ability to more easily override HTTP verbs for clients that don t support PUT and DELETE. Cached operation responses with WebCacheAttribute. Tons of code samples illustrating how to work with these features. The idea behind releasing the starter kit was to get these features into the hands of RESTful WCF developers so that they could provide feedback on features so that.net 4.0 can include the most relevant features and include any refinements. Thus, many of these features will be included in the WCF 4.0 feature set. Basic Profile 1.2 As you may be familiar, there are a number of standards bodies that drive specifications implemented by platforms like WCF, including: W3C ( OASIS ( and WS-I ( The goal of the latter is to simplify how the plethora of standards is implemented in vendor platforms. In WCF, BasicHttp Binding supports Basic Profile (BP) 1.1 which is based on SOAP 1.1. This profile is grossly out of date, it does not support WS-Addressing semantics or MTOM. Thus, a new profile was born - BP 1.2. This new profile addresses errata for BP 1.1 and includes support for WS-Addressing and MTOM. WCF 4.0 will support this profile. NOTE: Do not confuse BP 1.2 (based on SOAP 1.1) with BP 2.0 (based on SOAP 1.2) which is still a work in progress. Fig. 1: Discovery probes and announcements from a high level Discovery messaging works because communication endpoints are well-known UDP addresses. WCF 4.0 makes it very easy to implement service discovery with a few simple steps: Services that wish to be discoverable implement a discovery endpoint and enable discovery with a service behavior. Services that wish to send discovery announcements enable announcements as part of the discovery behavior. Clients that wish to probe services within the subnet use a built-in DiscoveryClient and supply heuristics for searching for the desired services. There are many architectural scenarios that can implement discovery, and this will be the subject of a future article. Router service Routers can be very useful when you need to introduce load balancing using custom heuristics, content-based or priority routing, versioning scenarios, or when you need to introduce a security boundary between remote clients and services that live behind the DMZ. Implementing a custom router is a significant undertaking but WCF 4.0 aims to relieve this effort by supplying us with a built-in router equipped to work with one-way, two-way and duplex messaging. You host the new RouterService as you would any other WCF service and then configure routing rules using a filter table and a set of associated filters. The filters are ultimately evaluated to determine the correct downstream service endpoint to forward messages to. This architecture is illustrated in figure 2. Service discovery Speaking of protocol support, WCF 4.0 includes a long-awaited implementation of WS-Discovery. This specification documents a multicast protocol that issues SOAP messages over UDP. Services that implement discovery endpoints can receive probe messages from clients that wish to discover services within their subnet. In addition, services can announce themselves to clients listening for announcements. Figure 1 illustrates the flow of communication between clients and services. WCF 4.0 includes implementation of WS-Discovery Fig. 2: Configuring the RouterService in WCF 4.0 Many filtering options are available through a simple configuration such as XPath queries for content-based routing and queries based on the SOAP action header. There are also extensibility hooks available for deeper control over filters and routing decisions. 10 MAGAZINE

11 .NET Workflow services New features in WCF 4.0 and WF 4.0 yield a more compelling story for implementing services operations as Workflow Services. In.NET 3.5 one usually restricted the use of Workflow Services to asynchronous, long-running processes that could withstand the overhead of the Workflow Runtime. In.NET 4.0 the Workflow Runtime performance is significantly improved removing that limitation. Instead the choice to use Workflow Services is purely driven by design choices and singular benefits such as: Increased visibility through correlated WF tracking and WCF tracing events. Greatly simplified approach to implementing asynchronous programming models, for example issuing downstream service calls in parallel and correlating responses. Implementing declarative (XAMLX) services which provide an alternative to deploying, updating and versioning - and make it possible to deploy Workflow Services to the cloud. High-performance tracing WCF 4.0 trace events are based on Event Tracing for Windows (ETW) which significantly enhances tracing and diagnostics performance. From a high level the architecture of ETW is simple: event providers push events to sessions under a registered provider ID, controllers are used to enable or disable sessions that collect events and associate providers with sessions, sessions can optionally persist events to a log, consumer applications listen to real-time session events or pick events up from trace logs. ETW is buffered to reduce contention when persisting events to a file-based trace log. Figure 3 illustrates this architecture. Additional resources Learning WCF, O Reilly 2007 (reprinted for VS 2008, August 2008) (get all the latest book code here!) Michele s blog: IDesign: Michèle Leroux Bustamante Michèle Leroux Bustamante is Chief Architect of IDesign Inc., Microsoft Regional Director for San Diego, Microsoft MVP for Connected Systems. At IDesign Michele provides training, mentoring and high-end architecture consulting services focusing on service-oriented architecture, interoperability, scalability, security, and globalization. Her specific technology focus includes WCF, federated security platforms and tools, CardSpace, Azure and Oslo. She is a member of the International.NET Speakers Association (INETA), a frequent conference presenter, conference chair for SD West, and is frequently published in several major technology journals. Michèle is also Program Advisor to UCSD Extension. Her latest book is Learning WCF (O Reilly 2007, updated August 2008) see her book blog here: Reach her at mlb@idesign.net, or visit and her main blog at TIP: Microsoft Tag Na het kopen van een nieuwe Windows Mobile phone (HTC Touch HD) met een onbeperkte internetverbinding moet er het uiterste uit de kast gehaald worden om alle mogelijkheden van deze telefoon te benutten. Het is inmiddels gewoon om internet als informatiemedium te gebruiken. Nu werkt het nog met links. Nieuwsbladen, tijdschriften, bushokjes je kunt het zo gek niet bedenken of er staan links. Maar het kan sneller en makkelijker met Microsoft Tag. Fig. 3: WCF Tracing and WF Tracking with ETW Both WCF and WF share the same ETW event provider so that a correlated view can be presented for WF tracking events and WCF tracing events - very useful for trouble-shooting Workflow Services. Furthermore, Dublin provides a friendly interface to enabling and configuring tracking and tracing through IIS Manager. Microsoft Tag is een online applicatie die een Tag kan generen. Naast de online applicatie is er een mobile plugin waar de camera geactiveerd kan worden. Deze Tag kan worden gelezen door jouw Windows mobile Phone. Een tag ziet er als volgt uit: Conclusion The new features in WCF 4.0 traverse a number of areas including configuration, tracing, serialization, message queuing, service discovery, routing and workflow services. All of these new features specifically address pain points that developers have with earlier versions of WCF. This article originally appeared in the 2009/April issue of asp.netpro magazine and is reprinted with express permission of Penton Media ( Download nu de plugin op Jordy van Paassen - VXCompany magazine voor software development 11

12 Advertentie Avanade

13 DATABASES Jessica M. Moss Designing Recoverable and Restartable SSIS Packages Due to unexpected data, server downtime, or a myriad of other reasons, a SQL Server Integration Services (SSIS) package will inevitably fail at some point in its lifetime. Initially designing your package to handle these situations will save support time and cost. This article introduces methods intended to create a recoverable and restartable package. SQL Server Integration Services Packages SQL Server Integration Services, a component of SQL Server 2005 and 2008, allows developers to create packages that contain work and data flows to perform a variety of tasks, such as populating a data warehouse through an extraction, transformation, load (ETL) process and performing database maintenance on an automated schedule. Along with using connection managers to access data sources, SSIS packages are tightly tied to the metadata associated with the data sources, including the object names and data types. Designing SSIS packages can be an art, and using best practices while architecting your entire solution can save you a lot of heartache in the end. For a majority of SSIS packages, recoverability and restartability should be the top design concern Common SSIS package execution problems Even if your SSIS package s business logic has been designed perfectly, at some point a package execution will likely fail. We can group many of the reasons for a package error into several categories. Category 1: External System Downtime contains failures that relate to an inability to reach an external system. This could be due to the intranet/internet not responding, a server participating in an unexpected downtime, or similar reasons. Category 2: Unexpected Data includes problems with the source data, which contain data type mismatches and arithmetic overflows. Finally, Category 3: Metadata Change issues occur because of a change to a table name, column name, or data type. Metadata Change errors happen because SSIS packages are tightly tied to the metadata of the original source. Recoverability and restartability Recoverability is the idea that a failure of an execution will never corrupt the state of the application. In an SSIS package, this means that if an execution fails, no data is lost or corrupted, and any effects from a failed execution do not affect a later execution of the same package or any other associated package or query. No discussion of recoverability would be complete without mentioning transactions, which are typically found in databases as an application of recoverability. Following the four principles of transactional systems, atomicity, consistency, isolation, and durability, will result in a recoverable system. Restartability allows you to restart an application to pick up where the last execution left off. In an SSIS package, if the last execution resulted in a failure, the restart will begin at the point of failure. On the other hand, if the last execution was successful, a later execution will start at the beginning of the package. If multiple tasks must run in the event of a failure, the SSIS package can be configured to handle this as well. When to use recoverability and restartability in an SSIS package? For a majority of SSIS packages, recoverability and restartability should be the top design concern. Whether in the form of an ETL process or performing database maintenance, the package will be managing data or manipulating something in a database. In particular, an ETL process typically needs high reliability and cannot lose a single record. If a package fails in the middle of a data load, you must have the ability to recover your data. Once you ve designed your package to handle recoverability, you can focus on restartability without having to worry about losing any data. In an ideal system, the SSIS package will rerun without any manual manipulation of the data and begin at the location of the last failure. Designing recoverability and restartability in an SSIS package Because of the importance of recoverability and restartability when running SSIS packages, we will take a look at a few methods to address this concern. Transactions One method to create recoverability in an SSIS package is to utilize package transactions. Transactions built into SSIS use the Microsoft Distributed Transaction Coordinator (MSDTC) and can be set to run for the entire package, a container that encloses tasks, or a task itself. Similar to database transactions, any failure within these items will undo the work already completed by the other items included in the transaction. This method ensures that any database commands enclosed in the transaction will either all execute or none of them will complete. This is especially useful in the scenario where you cannot delete a record in a staging table until you ensure the entry is in the final table, and conversely, if the entry has made it into the final table, you want to ensure the deletion from the staging table to prevent reloading. Using a transaction can assist in an error from any of the three error categories. Keep in mind that a transaction cannot contain any file based tasks, such as create, delete, move, as it cannot rollback those particular magazine voor software development 13

14 DATABASES operations. If the rollback process should include file based operations, you will need to code the opposite operation in the event of a failure in the package. DROP DATABASE AdventureWorksSnapshot Listing 3: Drop snapshot T-SQL statement To set up a transaction in your SSIS package that will not allow dirty reads nor allow other transactions to modify the current set of data, select the package/containers/tasks that you want included in the transaction and set the properties as shown in table 1. Property Name IsolationLevel TransactionOption Property Value RepeatableRead Required Table 1: Transaction properties P Database snapshot Another method to make a package recoverable utilizes database snapshots. SQL Server 2005 first introduced database snapshots, and other relational database management systems (RDBMS) may or may not include similar functionality. In this scenario, the package takes a database snapshot, which will store any changes to the database following the time the snapshot was taken. If the package execution fails in any way, the package restores the latest snapshot, wiping out any changes that took place during the package execution, thus returning the database to its original version. This snapshot method wipes the slate clean in the event of a failed load. It will reset the entire database in case of a partial load due to an External System Downtime or an insert failure due to Unexpected Data. You can then fix the source data if needed and rerun the package. This method can only be used if no other applications will be modifying the database at the same time your SSIS package runs, as it does not differentiate between changes made by your SSIS package and any other application. A slight performance overhead associated with writing to the database snapshot when the database changes affects the SSIS package as well. To implement this method in your SSIS package, add an Execute SQL Task in the Control Flow that precedes all other tasks. This task contains a T-SQL script similar to listing 1. Encapsulate all package logic in a Sequence Container, and attach a Failure precedence constraint from the Sequence Container to a second Execute SQL Task. This task contains the T-SQL script, found in listing 2, to restore and then drop the database snapshot. Set a second precedence constraint to execute on Success and attach it from the Sequence Container to a third Execute SQL Task, which contains a T-SQL script, found in listing 3, to drop the snapshot. Find a picture of a sample package using this snapshot logic in figure 1. CREATE DATABASE AdventureWorksSnapshot ON ( NAME = AdventureWorks_Data, FILENAME = 'C:\SSIS\AdventureWorksSnapshot.ss' ) AS SNAPSHOT OF AdventureWorks Listing 1: Create snapshot T-SQL statement USE master GO RESTORE DATABASE AdventureWorks FROM DATABASE_SNAPSHOT = 'AdventureWorksSnapshot' GO DROP DATABASE AdventureWorksSnapshot Listing 2: Restore snapshot T-SQL statement Fig. 1: Database snapshot package Create data subsets In this method to make an SSIS package recoverable, the SSIS package contains logic to chunk the source data into smaller pieces in order to reduce the subset that does not process successfully. Each section of data is inserted into the final destination using a bulk insert command that only commits on the insertion of all records in the subset. The entire subset fails if one record fails. This method has the benefit of completing as much of the processing as possible without corrupting the data. The SSIS package will not load the subset of data that contains Unexpected Data to allow you to fix the data before rerunning that subset of data, but all other subsets will load. Keep in mind a few things when working with this method. If you need an aggregate value over your subsets, this could complicate your logic. Also, this could slow down your processing by creating a semi-iterative approach rather than the normally used set-based approach of loading data. To implement one variation of this method, create an SSIS package to filter the data by modified date. Add an Execute SQL Task to the SSIS package that executes the T-SQL found in listing 4 and stores the result set into an object variable. Add a ForEach Loop that enumerates through each of the dates, assigning the value to a variable of a string data type. Within the ForEach Loop, use a Data Flow Task that performs the insert using the previously assigned variable. Find a picture of a sample package using this data subset logic in figure 2. SELECT DISTINCT CONVERT(varchar(10),ModifiedDate,101) as ModifiedDate FROM Sales.SalesOrderDetail WHERE ModifiedDate NOT IN ( SELECT DISTINCT FullDateAlternateKey 14 MAGAZINE

15 DATABASES FROM AdventureWorksDW2008.dbo.FactInternetSales fact INNER JOIN AdventureWorksDW2008.dbo.DimDate dim ON fact.orderdatekey=dim.datekey) Listing 4: Distinct dates T-SQL statement Process control table Creating a process control table is another way to enable restartability in an SSIS package. This process control table will contain a list of the tasks that have run successfully. If the execution of an SSIS package fails, those tasks not yet completed will not be entered into the process control table. The next time the package run, the package will only run the remaining tasks. After a successful execution, the package deletes all tasks records from the process control table. The process control table gives a higher level of control over the execution of the package. You can create an SSIS package that has parallel flows and ensure the execution of each task appropriately. Also, if you determine after the SSIS package has already run that you need to rerun a task that has already run or prevent a task from running, you can simply modify the table, and the SSIS package will pick it up during its next run. This method will handle restartability that needs to occur after a package failure due to any of the three error categories. Using this method incurs extra development time of creating the process table, handling the conditional logic within the SSIS package, and creating a standard for task name management. This method should only be undertaken if such fine grain control as mentioned above proves necessary. Fig. 2: Create data subset package Checkpoints To make a package restartable, SSIS has a feature called checkpoints that keeps track of the tasks that have executed successfully and the state of the variables and configurable values at the time of failure. If a package execution fails, the checkpoint file created will tell the package to start at the task that failed during the previous execution. Checkpoints allow you to automatically start the package at the point of failure. If an External System Downtime caused the failure, you can restart the package and it will not need to redo any of the work it had completed successfully, and it can pick up right at the failed task. In the same vein, if an Unexpected Data or Metadata Change problem occurred, you can fix the issue, knowing that the package will get back online and runs as soon as possible. Keep in mind that checkpoints only work with Control Flow Tasks. Also, if you need to rerun the entire package after a failed run, you will need to delete the checkpoint file. Finally, this method doesn t allow you to pick and choose where the package next starts up; it will always start at the task that most recently failed. To implement checkpoints in your SSIS package, set the FailPackageOnFailure property to True on each task that you would to participate in the restartability, and set the properties on the package as shown in table 2. Property Name CheckpointFileName CheckpointUsage SaveCheckpoints Table 2: Checkpoint package properties Property Value C:\SSIS\checkpoint.xml IfExists True To create the process control table, run the T-SQL script found in listing 5. In an SSIS package, add a Sequence Container that contains an Execute SQL Task. This task should contain the T-SQL statement found in listing 6 and will retrieve a single row from the process control table that tells the package which tasks to run. The single row result set should put the values into string variables representative of the columns from the query. In this example, create two variables: Task1 and Task2. Connect a precedence constraint from the Execute SQL Task to another Sequence Container that uses the expression found in listing 7. This prevents the Sequence Container from running if the task name is in the process control table. Add two Execute SQL Tasks inside the inner Sequence Container, and set up a transaction on this Sequence Container to ensure both statements run atomically. The last Execute SQL Task will insert the task name into the process control table; the T-SQL statement can be found in listing 8. Follow the same procedure of adding the inner Sequence Container and two Execute SQL Tasks to create a second task grouping. Finally, add a success precedence constraint from the outer Sequence Container to an Execute SQL Task. Use the T-SQL statement in listing 9 to delete all tasks from the process control table once all execution finished. See the final package in figure 3, which shows the layout and design of all tasks. CREATE TABLE [dbo].[processcontrol]( [Package] [varchar](50) NOT NULL,[Task] [varchar](50) NOT NULL) Listing 5: Create process control table T-SQL statement SELECT ISNULL(SUM(CASE WHEN Task = 'Task1' THEN 1 ELSE 0 END),0) AS Task1,ISNULL(SUM(CASE WHEN Task = 'Task2' THEN 1 ELSE 0 END),0) AS Task2 FROM dbo.processcontrol WHERE Package = 'SDN_ProcessControl' Listing 6: Get task list T-SQL == 0 Listing 7: Precedence constraint expression INSERT INTO dbo.processcontrol VALUES ('SDN_ProcessControl','Task1') Listing 8: Update process control table T-SQL statement magazine voor software development 15

16 DATABASES DELETE dbo.processcontrol Listing 9: Delete process control table T-SQL statement Conclusion This article covered a number of methods that can create a more reliable SSIS package. Each method has advantages and disadvantages, as discussed in each section. As with any application, implement the methods that make the most sense for your organization and your specific package scenario. If you can use one or a combination of these methods in your original design, you will end up with a more reliable, recoverable, and restartable SSIS package. Jessica M. Moss Fig. 3: Process control package Jessica M. Moss, a Microsoft SQL Server MVP and business intelligence mentor with Solid Quality Mentors, is certified as an MCDBA, MCTS: SQL Server 2005 BI, and an MCITP: SQL Server 2005 BI. She has been working with SQL Server 2005 since its release and has participated in many warehousing and reporting solutions. Jessica enjoys working with the local community and is a regular speaker at user groups, code camps, and conferences. You can read about her work on her blog, Advertentie MI Consultancy 16 MAGAZINE

17 ARCHITECTURE Astrid Hackenberg Green Computing: Sparen door te Delen Als ontwikkelaar en architect hebben wij veel invloed op onze leefomgeving; hier moeten we wat mee! Veel mensen gebruiken thuis groene stroom of zijn op andere manieren bezig met een beter milieu. Denk je hierover ook na wanneer je software ontwikkelt? Het idee van green computing gaat gelukkig steeds meer leven: wij als software bouwers moeten bijdragen aan een beter milieu. Dit artikel geeft een overzicht van green computing. Het gaat uiteindelijk allemaal over delen, simpel toch, dus begin er vandaag nog mee! Wat is het probleem? In de basis is het probleem eenvoudig: we verbruiken als IT-industrie teveel energie. Deze energie moet worden opgewekt en dit is niet goed voor de CO2-uitstoot, en daarmee slecht voor het milieu. Deze energie wordt gebruikt om onze computers in leven te houden. De CPU eet energie, de disks eten energie, maar ook de koeling van onze rekencentra verbruikt veel energie. De hoeveelheid energie die door computers wordt opgeslokt is enorm. Je moet denken aan ongeveer 2% van alle energie die wordt verbruikt in een gemiddeld West Europees land! De benodigde energie schijnt iedere vijf jaar ook nog eens te verdubbelen. Kortom, het is substantieel! Ook wij, als developers en architecten, kunnen ons dit aantrekken. Jarenlang zijn wij verwend dankzij de wet van Moore. De hoeveelheid rekenkracht, disk en geheugen kon niet op. Het tijdperk dat we er serieus over nadachten om ons programma zo klein en efficiënt mogelijk te maken ligt al ver achter ons. Kortom, wij consumeren al die resources zonder enig nadenken. Fig. 1: De wet van Moore Zo ontwikkelen wij b.v. de meeste van onze code niet alleen op een single-processor machine, maar ook voor een single-processor machine. Het is niet ongebruikelijk dat deze code vervolgens op een server komt te draaien die meerdere processoren heeft. Dat betekent dat de code draait op een machine die een overvloed heeft aan rekenkracht waar geen gebruik van wordt gemaakt, maar waar helaas wel voor moet worden betaald. Ook wanneer een processor niets doet, wordt er de nodige energie verbruikt, helaas. Herken je deze situatie? Waarschijnlijk is het grootste probleem dat we helemaal geen rekening houden met green computing tijdens ons ontwikkelproces. We vinden het gewoonweg niet belangrijk genoeg. Er worden geen eisen gesteld ten aanzien van green computing, maar wel aan schaalbaarheid, performance en beschikbaarheid. Sterker nog, vaak staan de eisen die we stellen green computing in de weg. Beschikbaarheid wordt vaak opgelost met meer en redundante hardware. Schaalbaarheid betekent vaak dat we uitgaan van het scenario dat we de maximale load op ieder willekeurig moment aan moeten kunnen; opnieuw resulteert dit in veel hardware. Wat is green computing? Waar hebben we het eigenlijk over wanneer we over green computing praten? Bij green computing denken we na over hoe we software en infrastructuur kunnen ontwikkelen die vriendelijk zijn voor het milieu. We denken na over hoe we applicaties kunnen ontwerpen en realiseren die het gebruik van resources minimaliseren. Bij green computing wordt vaak alleen aan infrastructuur gedacht, maar de softwarearchitect en -ontwikkelaar hebben minimaal evenveel invloed. Zij nemen dagelijks diverse beslissingen die een positieve of negatieve invloed hebben op green computing. Is green computing voor iedereen interessant? Ik denk van wel. We hebben met elkaar natuurlijk een morele verantwoordelijkheid, maar er is ook een andere reden. De belangrijkste reden om na te denken over green computing is geld! De hoeveelheid energie die wordt verbruikt is natuurlijk aanzienlijk voor een organisatie, en hiervoor moet worden betaald. In de toekomst kunnen we verwachten dat de kosten, maar ook zeker de belastingen, voor energie zullen toenemen. Green computing betekent dat er minder energie wordt gebruikt, en dus dat er bespaard kan worden. Dat is toch voor iedereen interessant? Green computing == delen Hoe begin je met green computing? De basisgedachte van green computing is om niet alles voor jezelf te willen hebben, maar dat je juist gaat delen. Eigenlijk is green computing niets meer of minder dan alles eerlijk delen. Dit klinkt logisch maar is helaas voor de meeste magazine voor software development 17

18 ARCHITECTURE ontwikkelaars en architecten niet vanzelfsprekend. Wij realiseren vaak producten waarvan we eisen dat deze exclusief en zelfstandig op een machine draaien. Deze software heeft dan specifieke afhankelijkheden, anders dan een eventueel ander product. Om conflicten te vermijden eisen we exclusiviteit. Het delen wordt vaak gerealiseerd door virtualisatie. Dit is een begrip Eigenlijk is green computing niets meer of minder dan alles eerlijk delen dat de laatste jaren steeds meer aan populariteit heeft gewonnen. In basis is virtualisatie niets anders dan het idee om met elkaar resources te delen. Virtualisatie kan klein beginnen en uiteindelijk eindigen in cloud computing. Recentelijk kwam ik bij Microsoft de volgende tabel tegen met virtualisatieniveaus: Virtualisatie- Naam Applicatie Infrastructuur Locatie Eigenaar niveaus Niveau 0 Local Dedicated Fixed Gedistribueerd Intern Niveau 1 Logical Shared Fixed Gecentraliseerd Intern Niveau 2 Data Shared Virtueel Gecentraliseerd Intern center Niveau 3 Cloud Software as Virtueel Virtueel Virtueel a Service V Tabel 1: Virtualisatieniveaus De meeste organisaties verkeren momenteel op niveau 1, al heeft niveau 2 de laatste tijd sterk aan populariteit gewonnen. Aan de niveaus kunnen ook technologieën worden gekoppeld. Deze technologieën zijn weergegeven in tabel 2. Virtualisatie- Technologie-Aspecten niveaus Naam Server Opslag Netwerk Niveau 0 Local Standalone PC Lokale disk Geen Niveau 1 Logical Client/server File server LAN N-tier Database server Niveau 2 Data center Server SAN WAN/VPN virtualisatie Niveau 3 Cloud Cloud platform Cloud storage Internet Tabel 2: Technologie-aspecten voor virtualisatie Op ieder niveau zijn er verbeteringen mogelijk. In de rest van dit artikel worden de niveaus in meer detail beschreven en wordt er ingegaan op de mogelijke design- en implementatie-verbeteringen. Wat kun je doen op niveau 0? Dit is het niveau waar alles lokaal draait, op de eigen machine dus. Op dit niveau wordt er eigenlijk niets gedeeld. Toch zijn er op dit niveau verbeteringen mogelijk. Er wordt namelijk energie verbruikt. Wanneer we de hoeveelheid benodigde energie naar beneden kunnen brengen is dat dus ook winst. Traditionele ontwerpen houden vaak op geen enkele wijze rekening met de hoeveelheid energie die nodig is. Bij veel operating systems is daar al wel over nagedacht. Vaak heeft dit geresulteerd in een slaap/wachtstand-mode waarin de computer aanzienlijk minder energie verbruikt. Onze software staat echter een dergelijke mode vaak in de weg omdat we resources blijven claimen. Denk hierbij bijvoorbeeld aan connecties die we open hebben staan, ook op het moment dat er niets gebeurt in de applicatie. Verder gebruiken we in onze applicaties vaak een overdaad aan data. Deze data moet van disk komen (en weer worden teruggezet). De disk is vaak niet de duurste resource, maar blijft toch een resource die energie nodig heeft. Heb je ooit naar je applicatie gekeken met de gedachte om de hoeveelheid diskaccess te beperken? Verder raad ik iedereen aan om eens met een device driver programmeur te praten. Bij deze programmeurs staat een minimaal en efficiënt design nog steeds hoog op de prioriteitenlijst. Een applicatie-ontwerp waarbij zo min mogelijk gebruik gemaakt wordt van de processor en het geheugen is ook efficiënter met energiegebruik. Wat kun je doen op niveau 1? Op dit niveau beginnen we met delen. De eerste stap is vaak een gemeenschappelijke database-server, maar ook mail-, internet-, fileen print-servers worden gedeeld. Dit is het niveau waarop client/ server applicaties worden ontwikkeld. Wanneer gekozen wordt voor een n-tier architectuur wordt vaak ook een applicatie-server geïntroduceerd. Van niveau 0 naar niveau 1 is een flinke stap voorwaarts. Op dit niveau kan ook nog de nodige consolidatie plaatsvinden. Heb je echt al die servers nodig? Het is aan de applicatieprogrammeur om er voor te zorgen dat de applicatie geen exclusiviteit nodig heeft, en dat is een essentiële voorwaarde om te kunnen delen. De software-architect speelt op dit niveau ook een belangrijke rol. Het is aan de architect om te zorgen dat er een architectuur en infrastructuur komt waarin kan worden gedeeld. Het is bijvoorbeeld makkelijker om met elkaar dezelfde SQL Server instantie te delen dan wanneer het noodzakelijk is om én Oracle én SQL Server op een systeem te delen. Zorg als architect voor een enterprise architectuur waarin delen mogelijk is! Dit is ook het niveau waarop ik thuiswerken zie. Maak het dus mogelijk om thuis te werken. Zorg dat je remote bij mail, files en andere resources kunt komen, b.v. door gebruik van VPN. Thuiswerken past prima in het plaatje van green computing! Thuiswerken past prima in het plaatje van green computing! Wat kun je doen op niveau 2? Dit is het niveau waaraan de meeste mensen denken wanneer ze het woord virtualisatie horen. Dit is het niveau waarop alle data wordt geconsolideerd op een SAN in een rekencentrum. Dit is het niveau waar virtualisatiesoftware zoals Microsoft Virtual Server of VMWare wordt gebruikt. Op dit niveau gaan we nadenken over het optimaal gebruiken van onze servers. Een zeer aansprekend voorbeeld voor software-ontwikkelaars is de virtualisatie van de OTAP-omgeving. Het is toch niet noodzakelijk om voor iedere omgeving binnen de OTAP een fysieke server beschikbaar te hebben logisch toch? Maar er zijn meer mogelijkheden. Je kunt b.v. bedenken om de printof applicatie-server s avonds te stoppen en in de ochtend weer te starten. Het starten en stoppen van virtuele machines is standaard functionaliteit die kan worden toegepast. Wat kunnen wij doen als ontwikkelaars? Zorg ervoor dat je applicatie geen directe afhankelijkheid heeft van de onderliggende hardware. Zorg ervoor dat jouw applicatie kan draaien in een virtuele machine! Wat kun je doen op niveau 3? Dit is het niveau waarop de droom van alles delen werkelijkheid wordt. We delen resources in de cloud en richten niet meer onze eigen rekencentra in. We maken gebruik van de schaalgrootte die voordelig is voor het totale energieverbruik. Heel eenvoudig: 2 servers die voor 50% worden belast zijn nadeliger voor het milieu dan 1 server waarop 2 virtuele omgevingen draaien waardoor de machine voor 100% wordt belast. Veel leveranciers zijn momenteel bezig om cloud computing te realiseren. Partijen als Amazon en Google hebben of richten grote rekencentra in om ons te voorzien van cloud computing. Ook Microsoft begeeft zich nadrukkelijk op dit front met het Azure Services Platform. 18 MAGAZINE

19 ARCHITECTURE Ook binnen cloud computing kennen we verschillende varianten: Software as a Service (SaaS) Attached services Cloud platforms De verschillende typen cloud computing zijn weergegeven in figuur 1. Fig. 2: Verschillende typen cloud computing Ook bij cloud computing zijn er dus nog diverse keuzes te maken. De ene keuze heeft een voordeliger effect voor green computing dan de andere. Nog steeds blijft gelden: des te meer je deelt, des te beter. Toch blijft het ook noodzaak om bewust voor een leverancier en een datacentrum te kiezen. Hoe gaan de leveranciers met energie om? Waar is het rekencentrum gebouwd? Een rekencentrum in Finland is minder kosten kwijt aan koeling dan een rekencentrum in Zuid-Spanje. De keuze voor cloud computing levert de ontwikkelaar het meeste werk op. Een applicatie ontwikkelen voor de cloud vereist namelijk specifieke design- en programmeervaardigheden. Is een applicatie werkelijk altijd beschikbaar? Wat wanneer dit niet het geval is? Het ontwerp van de applicatie moet hier mee om kunnen gaan. De meeste cloud leveranciers bieden momenteel een eigen API. Je moet kennis opdoen van deze API. Daarnaast zijn er op dit moment geen relationele databases beschikbaar in de cloud, maar wordt alle data hiërarchisch opgeslagen. De applicatie moet daar mee om kunnen gaan. Kortom veel werk aan winkel! Conclusie Vandaag is een goed moment om na te gaan denken over green computing. Alle middelen en technieken zijn voorhanden om het beter te gaan doen. Dit is een goede zaak voor het milieu, maar zeker ook voor onze portemonnee. Green computing is niet alleen iets voor die ander, maar is ook voor ons als software-ontwikkelaars van belang. Misschien hebben wij wel de meeste impact wanneer het green computing betreft. We zouden wellicht labels moeten gaan toekennen aan onze software die aangeven hoe groen we zijn. De IT zou niet de eerste branche zijn waar dit gebeurt. Laten we in ieder geval beginnen met te delen!op z n minst kunnen we beginnen bij onze eigen computers. Hoe efficiënt is jouw software? Staat jouw ontwikkelcomputer altijd aan? Gebruik je een slaapstand? Een aardige start voor green computing is te vinden op op Astrid Hackenberg Astrid Hackenberg is mede-oprichter van Class-A en werkzaam als adviseur, trainer en coach. Haar werkgebied is het Microsoft applicatie platform en dan met name serveroplossingen gebruikmakend van BizTalk Server, SQL Server, Share- Point Server. Advertentie Sybase ianywhere

20 UX INFORMATION WORKER Beth Massi Using Windows Presentation Foundation and Line-of-Business Data in Microsoft Office Clients Windows Presentation Foundation (WPF) is a vector-based presentation system for building Windows client applications with visually stunning user experiences. WPF is an alternative to Windows Forms for designing user interfaces that uses a markup language called Extensible Application Markup Language (XAML) to provide new techniques for incorporating UI, media, and documents. Although Office solutions you build with Visual Studio are designed to work with Windows Forms controls, you can use WPF controls in your solutions as well. Any UI element that can host Windows Forms controls in a Visual Studio Tools for Office solution can also host WPF controls. One major benefit of using WPF controls in Office is that you are able to provide world-class data visualizations that are not possible with Windows Forms controls in an instantly familiar end-user application. Even the simplest controls that display data are often better off as WPF controls in Office applications because they better match the UI styles used in the latest versions of Office. Using WPF can make your add-ins look built into the Office applications themselves, providing a better user experience. In this article I will create a document customization for an Excel 2007 Workbook that is used by the Northwind Traders shipping department that pulls Order data from the Northwind database through an ADO.NET Data Service. The customization will display the order details in an Action Pane built with WPF and will allow users to update the order data through the data service. Even the simplest controls that display data are often better off as WPF controls in Office applications Exposing Line-of-Business (LOB) data to Office clients Before jumping into building the WPF control you need to think about how you can access data in your databases. There are a lot of options when thinking about how to expose your LOB data to Office clients. For instance, you may already have a service-oriented architecture at the enterprise that exposes data contracts and processes that you can consume from Office clients. Or maybe you have a small business and have decided to expose a simple service that returns and consumes n-tier data sets directly. Or you already have a custom LOB data entry system using custom business objects and you want to reuse the business layer in the Office client. Because you can consume data in Office clients the same way you do in other Windows applications the same types of decisions need to be made. Because there is only going to be simple CRUD (Create-Retrieve- Update-Delete) operations in this example, I will expose an Entity Data Model via ADO.NET Data Services. This allows you to get a secure service up and running in minutes. I will not spend much time on this but I ll show the basics. For more information on ADO.NET Data Services please read the article Using Microsoft ADO.NET Data Services in the MSDN library. To quickly build a data service for this example, create a new ASP.NET Web Application named NorthwindDataService and add a new item ADO.NET Entity Data Model (EDM) to the project that is generated from the Northwind database called NorthwindModel. Next add a new item and select ADO.NET Data Service and name it Northwind. (Please note: You will need Visual Studio 2008 Service Pack 1 in order to get these new item templates.) For testing, set the service to allow full access to all the entities in the model (but do not forget to lock it down later if you deploy to production). For this example I also am passing detailed errors which you will not want to do in production either. Public Class Northwind Inherits DataService(Of NorthwindEntities) ' This method is called only once ' to initialize service-wide policies. Public Shared Sub InitializeService( _ ByVal config As IDataServiceConfiguration) config.setentitysetaccessrule("*", _ EntitySetRights.All) config.useverboseerrors = True End Sub End Class 20 MAGAZINE

21 UX INFORMATION WORKER Now that the data is exposed as an ADO.NET Data Service you can build the Office client which will consume this service. Imports NorthwindExcelClient.NorthwindService Imports System.ComponentModel The Excel document customization To create a document customization for Excel, add a new project to the solution and select Office 2007 Excel Workbook which is available in Visual Studio 2008 Professional and higher. Since I am building a document customization and not an Add-In this means that code will only run on the specific document as opposed to running in the Excel application over any document that is opened. After the project is added, Visual Studio asks if you want to import an existing Excel workbook or create a new one. For this example create a new one named the same name as the project, i.e. NorthwindClientExcel.xlsx. After you specify this, the project is created and the Excel designer opens. The next step is to add the data service reference. Right-click on the project, select Add Service Reference. Click the Discover button and it should find the ADO.NET data service in the solution called NorthwindDataService. Name the service reference NorthwindService. This will generate the proxy to the service and the entity types on the client. Data binding in Excel Now that the service reference is created you can retrieve a list of Order entities that have not been shipped yet and display them in the first sheet of the workbook. But you will also want to show the Order Details and display the Quantity and Product that should be shipped. You will do this using an Excel Action Pane by setting up a masterdetail view of the data. So as the user scrolls through the Order rows, the Action Pane will display the Order Details in a WPF GridView. The user only needs to make changes to the Order rows so this design will work well. The magic control you use in Excel to bind data to rows is called the ListObject. This object can easily bind to a Winforms BindingSource just like any other Winforms control. To set up the data source so it can be bound to a BindingSource, you need to create a BindingList(Of Order) so that list change notifications are communicated to the UI. You also need to add code to the Order partial class on the client so that property change notifications are also sent. So first create a new class named Order and place it in the same Namespace as the NorthwindService service reference that was just added. This is where the client proxy objects are generated for you. In order to extend these classes with your own code, just place it into the same Namespace. (Here's a Visual Basic tip, you know you've got it right if you see the Order properties and methods in the Declarations drop down above the editor for the Order class.) You need to fire a change notification on all of the properties of the Order so I've placed code to do this in all the xxxchanged() partial methods. Take a look at the code download for how to do this. Next you need to create a BindingList(Of Order). I'm going to create a class called MyOrdersList that inherits from this which will also encapsulate the calls to the ADO.NET Data Service. MyOrdersList will use the data service context on the client (NorthwindService in this case) to retrieve and update the Orders. In this example you do not want to allow adds or deletes because orders are going through a workflow and our shipping department is only updating the information on an order, specifically the ShippedDate. So you need to override AddNewCore and RemoveItem to prevent this. Also override the OnListChanged so that the Order entity can be marked as updated. There are also couple housekeeping fields for saving and for exposing a HasChanges property. The interesting code to notice here is that the MergeOption is specified on the data service client to OverwriteChanges after the save, as opposed to the default AppendOnly. This means that after the changes are saved it will refresh the existing Order entity instances with changes from the database. Here is the beginning of the MyOrdersList class that handles this: Public Class MyOrderList Inherits BindingList(Of Order) Private DataServiceContext As New _ NorthwindEntities(New _ Uri(My.Settings.ServiceURI)) Private _haschanges As Boolean Private _issaving As Boolean Public ReadOnly Property HasChanges() As Boolean Get Return _haschanges End Get End Property Sub New() MyBase.New() Me.DataServiceContext.MergeOption = _ Services.Client.MergeOption.OverwriteChanges End Sub Protected Overrides Function AddNewCore() As Object Throw New NotSupportedException( _ "You cannot add items to the list.") Return Nothing End Function Protected Overrides Sub RemoveItem( _ ByVal index As Integer) Throw New NotSupportedException( _ "You cannot remove items from the list.") End Sub Protected Overrides Sub OnListChanged( _ ByVal e As System.ComponentModel.ListChangedEventArgs) If Not _issaving Then 'The Order partial class is implementing ' INotifyPropertyChanged so this will work If e.listchangedtype = _ ListChangedType.ItemChanged Then Me.DataServiceContext.UpdateObject(Me(e.NewIndex)) _haschanges = True End If MyBase.OnListChanged(e) End If End Sub Before I write the code that will retrieve and save the orders, I will bind this to a ListObject and get it onto the Excel worksheet. Since you will have to interact with the list of orders from Sheet1 as well as the Action Pane displaying the details, it is easiest to create a property on the Workbook itself that exposes the MyOrdersList. Double-click on the ThisWorkbook in the project and switch to the Code view and create a property to expose the OrderList. Now build the project and open the Data Sources window. Add a new Object Data Source and select MyOrderList then Finish. Drag the MyOrderList onto the designer for Sheet1, just drop it into the first cell, and it will generate all the columns for every property on the Order. You can also change the name of it on the Design tab and I'll change this one to OrderListObject as shown in figure1. magazine voor software development 21

22 UX INFORMATION WORKER For Each o In orders Me.Add(o) Next Me.RaiseListChangedEvents = True Me.OnListChanged(New _ ListChangedEventArgs(ListChangedType.Reset, 0)) Return Me.Count End Function Fig. 1: Drop data sources directly onto Excel sheets to set up data binding automatically Unfortunately it drops all the columns regardless if you select a drop target of none or not in the data sources window. Right-click on the column and select Delete from the drop-down menu to delete a column (do not press the delete key, use the context menu). For this example remove the first three and the last three columns that it dropped. Another quirk of the ListObject is that you will need to set any date fields to Text format. The ListObject will not let you change date values if the formatting isn't set to text. You do this by selecting the column then right-click, select Format Cells, and then select Text from the list. This is usually OK to do because the data source, in this case the Order, enforces the data type to be a date. You can be explicit about setting the data source and binding to columns in the startup event handler of the sheet as shown here: Public Class Sheet1 Private Sub Sheet1_Startup() Handles Me.Startup Dim myapp = NorthwindExcelClient.Globals.ThisWorkbook Me.OrderBindingSource.DataSource = myapp.orderlist Me.OrderListObject.SetDataBinding( _ Me.OrderBindingSource, "", _ "ShippedDate", _ "Freight", _ "ShipName", _ "ShipAddress", _ "ShipCity", _ "ShipRegion", _ "ShipPostalCode", _ "ShipCountry") Me.OrderListObject.AutoSelectRows = True myapp.loadorders() End Sub You should notice that the last line calls a method on ThisWorkbook to load the orders. In order to load the order entities you will write a query against the ADO.NET data service next. Querying and saving orders via the data service Looking back to the MyOrdersList class you can now write a method for returning the list of orders that have not yet been shipped. Call the service to return a list of unshipped orders, add them all to MyOrder- List and then raise the list changed event to notify the Excel ListObject to refresh its UI as shown here: Public Function LoadOrders() As Integer Me.Clear() Me.RaiseListChangedEvents = False Dim orders = From o In Me.DataServiceContext.Orders _ Where o.shippeddate Is Nothing _ Order By o.orderdate You will also need a way to load the order details, shipper and product entities when requested. This will happen as the user selects rows of data and you need to display these details in the Action Pane. By default these entity references and collections are not loaded so you need to do this explicitly. This is a good thing in this case because it avoids transferring unnecessary data if the user doesn't select the Order row in the sheet. Here is the code to load the details: Public Sub LoadOrderDetails(ByVal o As Order) If (o IsNot Nothing) Then If o.shipper Is Nothing Then Me.DataServiceContext.LoadProperty(o, _ "Shipper") End If If o.order_details Is Nothing OrElse _ o.order_details.count = 0 Then Me.DataServiceContext.LoadProperty(o, _ "Order_Details") For Each detail In o.order_details detail.order = o If detail.product Is Nothing Then Me.DataServiceContext.LoadProperty(detail, _ "Product") End If Next End If End If End Sub Finally you need a method that submits changes back to the data service. This is easily done by calling SaveChanges on the service context which sends all the changes that were made in the client through the service, i.e. Me.DataServiceContext.SaveChanges(). In this example they are not sent in a single batch, therefore if one order fails to update the ones before the failure will still be saved. Depending on your scenario you can opt to use a batch request by passing that flag in the call to SaveChanges. You also may need to put more robust error handling here depending on what kind of failures you anticipate in your applications. Simple error handling is done for this example in the Action Pane which you will build next. Creating an Excel action pane using WPF Now you are ready to design the Action Pane that will display the order details. The control will display this in a simple read-only GridView that matches the Excel blue gradients and fonts. It will also provide a status message area and a Save and Refresh button. Refresh will re-load the orders from the service and Save will send the changes back. (Later I ll show how you can hook up Excel's save button to do the same thing.) It will also run a couple of animations when rows are selected in the sheet to draw the user s attention to the Action Pane. This is because by default Action Panes are displayed on the right-hand side of the spreadsheet. In order to display WPF in a Windows Form control you use the Winforms ElementHost as a container for your WPF control 22 MAGAZINE

23 UX INFORMATION WORKER In order to display WPF in a Windows Form control, including Office solutions built with Visual Studio, you use the Winforms ElementHost as a container for your WPF control. This is found in the WPF Interoperability Tab on your toolbox. When you drop this control onto the designer you can immediately select the WPF user control to display. So first we need to build a WPF user control. Add a new item to the project and select WPF category on the left and then choose WPF User Control, I named it WPFActionPane for this example, and click OK. Take a look at the code sample for the full XAML source code which describes the layout and data bindings of the controls as well as the styles used to make the GridView have a nice Excel-friendly look. The following code listing highlights the basics: <UserControl x:class="wpfactionpane"... <UserControl.Resources> <Storyboard x:key="loadingstoryboard">... <Storyboard x:key="updatestoryboard">... <Style x:key="gridviewstyle" TargetType="TextBox">... <Style x:key="listviewstyle" TargetType="ListView">... <Style x:key="listviewitemstyle" TargetType="ListViewItem">... <Style x:key="gridviewcolumnheaderstyle" TargetType="GridViewColumnHeader">... </UserControl.Resources> <Grid Height="Auto" Width="Auto" Name="MainGrid"> <Grid.RowDefinitions>... <StackPanel Orientation="Horizontal"> <Button Height="40" Name="cmdSave"... <Button Height="40" Name="cmdRefresh"... </StackPanel> <StackPanel Grid.Row="1"> <TextBlock Name="txtShipper" Width="Auto" Height="25" Text="{Binding Path=Shipper.CompanyName, StringFormat=Ship via \{0\}}" Foreground="DarkBlue" /> <TextBlock Name="txtOrderDate" Width="Auto" Height="25" Text="{Binding Path=OrderDate, StringFormat=Ordered \{0:D\}}" Foreground="DarkBlue"/> </StackPanel> <Image Grid.Row="2" Source="northwindlogo.gif" /> <Grid Grid.Row="2" Background="White" Name="ListGrid"> <ListView ItemsSource="{Binding Path=Order_Details}" Style="{StaticResource ListViewStyle}" ItemContainerStyle="{StaticResource ListViewItemStyle}" Name="ListView1" Margin="4" IsEnabled="True" BorderThickness="0"> <ListView.View> <GridView ColumnHeaderContainerStyle= "{StaticResource GridViewColumnHeaderStyle}"> <GridViewColumn Header="Product"> <GridViewColumn.CellTemplate> <DataTemplate> <TextBox Text="{Binding Path=Product.Product- Name}" Style="{StaticResource GridViewStyle}"/> </DataTemplate> </GridViewColumn.CellTemplate> </GridViewColumn> <GridViewColumn Header="Quantity"> <GridViewColumn.CellTemplate> <DataTemplate> <TextBox Text="{Binding Path=Quantity, StringFormat='n0'}" Style="{StaticResource GridViewStyle}" /> </DataTemplate> </GridViewColumn.CellTemplate> </GridViewColumn> </GridView> </ListView.View> </ListView> </Grid> <Grid Grid.Row="3"> <TextBox Name="txtStatus"... </Grid> </Grid> </UserControl> The code that calls the load and save on the orders will be here since this control will interact directly with the list of Orders. In the codebehind of the WPFActionPane it also animates the control by running the StoryBoards defined in the XAML when either the order details are displayed or when the status messages at the bottom of the pane changes. Note that I also included the images referred by the XAML above into the project and set their Build Action to Resource in the properties for the files in the Solution Explorer. First pass the reference to the list of Orders into the WPF control and then set it as the DataContext. This will trigger all the data bindings to hook up to the currently selected Order s details as noted by the data bindings in the XAML above. For instance, if you want to display the shipper s company name then specify the Shipper.CompanyName path on the Order object contained in the list. The code for the WPF user control is as follows: Imports NorthwindExcelClient.NorthwindService Imports System.Windows.Data Imports System.Windows.Media Partial Public Class WPFActionPane Private _orderlist As MyOrderList Public Property OrderList() As MyOrderList Get Return _orderlist End Get Set(ByVal value As MyOrderList) _orderlist = value Me.DataContext = _orderlist End Set End Property Private Sub cmdrefresh_click() Handles cmdrefresh.click Me.LoadOrders() End Sub Private Sub cmdsave_click() Handles cmdsave.click Me.SaveOrders() End Sub Public Function SaveOrders() As Boolean Dim msg = Orders could not be saved. & vbcrlf Try Save changes back to the data service If Me.OrderList.SaveChanges() Then msg = Orders saved. End If Me.SetMessage(msg) Catch ex As Exception Me.SetMessage(ex.ToString()) End Try End Function Public Sub LoadOrders() Dim msg = magazine voor software development 23

24 UX INFORMATION WORKER Try Dim count = Me.OrderList.LoadOrders() msg = String.Format( {0} orders returned., count) Me.SetMessage(msg) Me.ButtonStack.Visibility = _ Windows.Visibility.Visible Catch ex As Exception Me.SetMessage(ex.ToString()) End Try End Sub Public Sub DisplayOrderDetails(ByVal o As Order) If o IsNot Nothing Then Me.OrderList.LoadOrderDetails(o) Dim view = _ CollectionViewSource.GetDefaultView(Me.DataContext) view.movecurrentto(o) Me.ListGrid.Visibility = Windows.Visibility.Visible Me.ListView1.SelectedIndex = -1 Dim story = CType(Me.Resources( LoadingStoryBoard ),_ Animation.Storyboard) story.begin() End If End Sub Public Sub SetMessage(ByVal msg As String) Me.txtStatus.Text = msg Dim story = CType(Me.Resources( UpdateStoryBoard ), _ Animation.Storyboard) story.begin() End Sub End Class Now you can create the Action Pane. Add a new item to the project and select Actions Pane Control from the Office group. I named it OrdersActionPane. This opens up the Windows Forms User Control designer and you can drop any Windows Forms controls on here. To add the WPF user control open the WPF Interoperability category in the toolbox and you should see the ElementHost control. Drag that onto the Actions Pane user control, click the smart tag in the upper right, and then select the WPFActionPane control as the hosted content and dock it in the parent container. You also need to set the font of the OrdersActionPane to Calibri 11 point. In the code behind for the OrdersActionPane set the OrderList for the WPF control and add a handler to listen to the position changed event on the OrderBindingSource that is hooked up as the DataSource of the ListObject on Sheet1. When the position changes the WPF control is notified to display the selected Order s details. There are many ways to integrate WPF and Windows Forms to manage data source currency but for this example let s keep it simple. The code for the OrdersActionPane is below: Private Sub DisplayOrderDetails( _ ByVal sender As Object, _ ByVal e As EventArgs) Dim source = TryCast(sender, BindingSource) If source IsNot Nothing Then If source.position > -1 Then Me.WpfActionPane1.DisplayOrderDetails( _ TryCast(source.Current, Order)) End If End If End Sub End Class You are almost ready to test this out. The last thing you need to do is load the Actions Pane when the application starts as well as expose a LoadOrders to our Sheet. This is because if you are adding charts, pivot tables or other types of controls for data analysis you cannot rely on the Action Pane loading the data, you need the sheet to be able to call upon it explicitly. You will also hook up the Excel BeforeSave event so that save can be called on the orders when users click the normal save button on the Excel toolbar. So back in the ThisWorkbook class enter the following code under the code you wrote previously: Private _orderactions As New OrdersActionsPane Private Sub ThisWorkbook_Startup( _ ByVal sender As Object,_ ByVal e As System.EventArgs) Handles Me.Startup 'Load the action pane Me.ActionsPane.Controls.Add(_orderActions) End Sub Public Sub LoadOrders() _orderactions.wpfactionpane1.loadorders() End Sub Private Sub ThisWorkbook_BeforeSave( _ ByVal SaveAsUI As Boolean, _ ByRef Cancel As Boolean) Handles Me.BeforeSave _orderactions.wpfactionpane1.saveorders() End Sub End Class Hit F5 and try it out. You will see all the Orders that have not shipped load into the sheet. As you select a row, the details are displayed in the Action Pane and an animation that shows the Northwind logo fades into and out of view so that it draws the user's attention to the Action Pane on the far right. Modify any of the fields in the Sheet and click the save button to save your changes back to the service. Figure 2 shows the Excel client as a new row is being selected and the transition is taking place on the WPF control on the Action Pane. Imports System.Data.Services.Client Imports NorthwindExcelClient.NorthwindService Public Class OrdersActionsPane Private Sub OrdersActionsPane_Load() Handles Me.Load Pass in our data source to the WPF control Me.WpfActionPane1.OrderList = _ NorthwindExcelClient.Globals.ThisWorkbook.OrderList When the position changes in the spreadsheet, display the order details in the WPF control AddHandler _ NorthwindExcelClient.Globals.Sheet1. _ OrderBindingSource.PositionChanged, AddressOf Me.DisplayOrderDetails End Sub Fig. 2: The Excel client with a WPF control on the Action Pane as a new row is being selected 24 MAGAZINE

25 This example is included in a complete Office Business Application (OBA) sample that is available online at The Excel client in that example also includes how to create a pivot table and chart that refreshes when the data comes back from the service. The other pieces of the sample show how to build a complete OBA solution using Outlook, Word and a SharePoint workflow and can be used independently so I encourage you to have a look. Using WPF in business applications built for Office is easy to do and provides a much better user experience and look-and-feel than traditional Windows Forms controls. You can easily make your add-ins and document customizations appear like they are truly part of the Office application itself. WPF makes it possible to provide stunning visualizations on top of your line-of-business data in an application that is very familiar to the end user. Enjoy! Beth Massi Beth is a Program Manager on the Visual Studio Community Team at Microsoft and is responsible for producing and managing content for business application developers, driving community features and team participation onto MSDN Developer Centers ( and helping make Visual Studio one of the best developer tools in the world. She also produces regular content on her blog ( Channel 9, and a variety of other developer sites and magazines. As a community champion and a long-time member of the Microsoft developer community she also helps with the San Francisco East Bay.NET user group and is a frequent speaker at various software development events. Before Microsoft, she was a Senior Architect at a health care software product company and a Microsoft Solutions Architect MVP. Over the last decade she has worked on distributed applications and frameworks, web and Windows-based applications using Microsoft development tools in a variety of businesses. She loves teaching, hiking, mountain biking, and driving really fast. Advertentie Aladdin UX TIP: 404 error pagina, hoe het ook kan Een 404 error pagina hoeft niet altijd het einde van het bezoek aan je site te betekenen. Goed ontworpen 404 error pagina s kunnen ervoor zorgen dat de bezoeker op je website blijft en alsnog de informatie vindt waar hij naar op zoek was. Laat de bezoeker weten waarom de pagina die hij/zij probeert te openen niet weergegeven kan worden en biedt alternatieve mogelijkheden, zoals een zoekmogelijkheid en (beknopte) navigatie. Meer informatie over 404 error pagina s en inspirerende voorbeelden zijn te vinden op

26 Advertentie Bergler

27 INFORMATION WORKER UX Mirjam van Olst Silverlight Web Parts in SharePoint Het gebruik van het three layered application pattern bij het bouwen van Silverlight web parts in SharePoint Met behulp van Silverlight kunnen applicaties met een rijke user interface gebouwd worden. Deze applicaties leven in de browser en kunnen bijvoorbeeld in een HTML pagina geplaatst worden. Daarnaast kunnen Silverlight applicaties ook in web parts gebruikt worden. Door het gebruik van Silverlight applicaties in SharePoint web parts krijg je the best of both worlds. Met de rijke user interface mogelijkheden van Silverlight kunnen prachtige, grafische web parts gebouwd worden met bijvoorbeeld mogelijkheden voor 3D en grafieken. Daarnaast zorgt het gebruik van Silverlight ervoor dat er minder pagina refreshes nodig zijn, waardoor het gebruik van de applicatie voor de gebruiker prettiger en sneller is. Tegelijkertijd kan gebruik gemaakt worden van bijvoorbeeld de collaboratie- en search-mogelijkheden van SharePoint. Dit artikel legt uit welke stappen nodig zijn om een Silverlight web part in SharePoint te bouwen en ook op welke manieren data uit de SharePoint omgeving in het Silverlight web part gebruikt kan worden. Wat is Silverlight? De meeste mensen zullen inmiddels waarschijnlijk wel weten wat Silverlight is. Voor de zekerheid toch nog even een samenvatting: Silverlight is een browser plugin De huidige versie van Silverlight is versie 2 - Versie 2 is in oktober 2008 gelanceerd - Versie 2 biedt ondersteuning voor het gebruik van Managed Code in Silverlight applicaties Om een snelle download mogelijk te maken is de plugin minder dan 5MB groot Silverlight is cross-browser, cross-platform; het draait bijvoorbeeld in Internet Explorer, Firefox en Apple Safari browsers en het draait op zowel Windows als Apple besturingssystemen De Silverlight applicatie draait dus op de client, niet op de server! Silverlight maakt het mogelijk om visueel sensationele en interactieve oplossingen te bouwen die in de browser draaien. Omdat de code in de browser draait, erft de Silverlight applicatie ook de eigenschappen van de browser. Dit betekent dat de code maar beperkte rechten heeft op de client. De reden hiervoor is dat je natuurlijk niet wilt dat een Silverlight applicatie die je in je browser bekijkt toegang heeft tot bijvoorbeeld je harde schijf. In Silverlight is het, net als in gewone ASP.NET pagina's en user controls, zo dat de user interface en de styling van een control volledig los staan van het gedrag van het control. Je gebruikt zelfs verschillende programma's voor het ontwikkelen van de logica en de user interface. Developers gebruiken hun vertrouwde Visual Studio 2008 omgeving voor het ontwikkelen van de logica van de Silverlight applicatie. Designers openen vervolgens hetzelfde project in Microsoft Expression Blend en gebruiken Blend voor het creëren van de user interface. Door het gebruik van verschillende tools mogelijk te maken kunnen zowel developers als designers gebruik maken van een omgeving die is afgestemd op hun specifieke wensen en eisen. In de Silverlight plugin zit het Silverlight.Net Framework. Het Silverlight.Net Framework is een uitgeklede versie van het gewone.net Framework. Als je ontwikkelt voor Silverlight, heb je dus niet alle classes uit het gewone.net Framework tot je beschikking. Aan de ene kant is dit een noodzaak, omdat eindgebruikers anders voor het draaien van een Silverlight applicatie het volledige.net Framework van ongeveer 200MB zouden moeten downloaden en installeren, in plaats van de 5MB van het Silverlight.Net Framework. Aan de andere kant is het ook logisch, omdat bepaalde classes niet vaak gebruikt zullen worden in applicaties die op de client draaien. Een voorbeeld hiervan is de System.Data.SqlClient namespace die gebruikt wordt voor het benaderen van een SQL Server database. Aangezien de SQL Server database meestal op de server zal draaien en niet op de client, zul je deze namespace niet missen bij het ontwikkelen van een Silverlight applicatie. Omdat de Silverlight applicatie op de client draait is het niet mogelijk om data of applicaties op de server direct te benaderen magazine voor software development 27

28 INFORMATION WORKER UX Omdat de Silverlight applicatie op de client draait is het niet mogelijk om data of applicaties op de server direct te benaderen. Je kunt dus het SharePoint Object Model niet direct aanspreken en je kunt data niet direct uit databases op de server lezen. Toch wil je de data uit de database, of een andere externe data bron, natuurlijk wel graag gebruiken in je applicatie. Geen nood, want Silverlight ondersteunt het gebruik van (web) services. Dit kunnen SOAP services zijn die gebouwd zijn met Windows Communication Foundation (WCF), of gewoon HTTP of REST services. Ook RSS feeds kunnen prima gebruikt worden voor het opvragen van data die in Silverlight web parts getoond wordt. Het voorbeeld: een Silverlight foto web part Als voorbeeld zullen we een Silverlight foto web part voor SharePoint gaan bouwen. Het web part toont een rij thumbnails met foto s uit een bepaalde databron. Als je een foto selecteert, dan wordt boven de rij met thumbnails de grote foto getoond. Het mooie aan dit web part is, dat je met dit ene web part foto s uit meerdere databronnen kunt tonen, terwijl de code van het web part zelf niet verandert. In dit artikel zal ik laten zien hoe je foto s uit een SharePoint picture library kunt tonen en hoe je foto s van Flickr kunt tonen. Voordat we kunnen beginnen met het bouwen van het web part moeten we eerst SharePoint configureren zodat de SharePoint web applicatie het gebruik van Silverlight ondersteunt. SharePoint configureren voor Silverlight Ik ga ervan uit dat je een SharePoint omgeving hebt opgezet waarop minimaal SP1 en de December Cumulative Update voor WSS en MOSS geïnstalleerd zijn. Daarna moet je de volgende stappen doorlopen om Silverlight web parts voor SharePoint te kunnen ontwikkelen: Installeer Visual Studio 2008 met SP1 Installeer het.net Framework 3.5 SP1 Installeer de Silverlight Tools voor Visual Studio 2008 SP1 Voeg de System.Web.Silverlight.dll file toe aan de Global Assembly Cache. De dll is normaal gesproken te vinden in de C:\Program Files\Microsoft SDKs\Silverlight\v2.0\Libraries\Server directory Registreer het.xap MIME type voor de web applicatie waarin je het web part wilt hosten. Dit doe je door de properties van de web applicatie in IIS te openen en dan op het tabje HTTP Headers op MIME Types te klikken. Voeg als Extension.xap toe en als MIME Type application/x-silverlight-app. Voeg de Silverlight elementen toe aan de web.config. De juiste toevoegingen kunnen gevonden worden op De SharePoint omgeving is nu geschikt voor het gebruik van Silverlight in pagina s en web parts. Je kunt nu beginnen met het bouwen van het Silverlight foto web part. Het three layered application pattern Het three layered application pattern is een software design pattern. Bij het three layered application pattern wordt de code opgebouwd in verschillende lagen, waarbij het idee is dat elk van deze lagen aan te passen is, zonder dat de andere lagen hier last van hebben. De drie lagen zijn als volgt gedefinieerd: Presentation. De presentatielaag levert de user interface van de applicatie. Dit kan zijn in de vorm van een Windows Form voor een smart client applicatie, maar het kan ook een.aspx pagina, een.ascx control of een Silverlight control zijn. Business. De businesslaag implementeert de business logica van de applicatie. De businesslaag bestaat vaak uit meerdere componenten, die binnen de businesslaag allemaal hun eigen functie hebben. Data. De datalaag geeft toegang tot externe systemen zoals databases en web services. Figuur 2 geeft een grafische overview van de verschillende lagen en componenten van het three layered application pattern. Fig. 2: Het three layered application pattern Een groot voordeel van het three layered application pattern, dat ook bij het bouwen van Silverlight controls erg duidelijk naar voren komt, is dat een developer de logica van de business- en de datalaag kan ontwikkelen, terwijl een designer vervolgens het design van de presentatielaag kan implementeren. Omdat ik absoluut geen designer ben, zal ik bij het bouwen van het Silverlight Foto web part nauwelijks design toevoegen, maar ik zal wel gebruik maken van het three layered application pattern. Hierdoor kan een designer later het design van de user interface aanpassen en verfraaien, zonder dat daarvoor de logica van het web part aangepast hoeft te worden. Meer informatie over het three layered application pattern kun je nalezen op Fig. 1: Het toevoegen van het.xap MIME type Het aanmaken van de Visual Studio solution De eerste stap in de implementatie van het web part is het aanmaken van het web part zelf. Maak hiervoor een project aan in Visual Studio 28 MAGAZINE

29 INFORMATION WORKER UX 2008 op basis van het ASP.NET Web Application project type. Ik noem het project Presentation.WebPartUI. Omdat we meerdere projecten aan de solution toe zullen voegen, krijgt de solution de naam SilverlightFotoWebPart. Fig. 5: Het aanmaken van een Silverlight test pagina in het Presentation.WebPartUI project Fig. 3: Het aanmaken van de solution en het Presentation.WebPart UI project Visual Studio maakt zelf bij het aanmaken van een web application project een App_Data folder, een default.aspx file en een web.config file aan. Deze zijn niet nodig voor het bouwen van een web part en kunnen dus uit het project verwijderd worden. De tweede stap in het realiseren van het Silverlight foto web part is het aanmaken van een Silverlight Applicatie project waarin de Silverlight Control zal worden opgeslagen. De naam van dit project kan Presentation.SilverlightUI zijn. Bij het aanmaken van dit project zal je gevraagd worden waar je de HTML pagina wilt hosten waarin je de Silverlight applicatie kunt testen. Kies hierbij voor de derde optie Link this Silverlight control into an existing Web site en voeg het toe aan het Presentation.WebPartUI project. Dit zal het testen en deployen van de Silverlight applicatie straks vergemakkelijken. Vink bij het aanmaken van je Silverlight project aan dat je het wilt testen in een bestaande website. Dit zal het testen en het deployen van de Silverlight applicatie vergemakkelijken De derde stap is het aanmaken van het project dat zorgt voor het ophalen van de data uit de Flickr website en de SharePoint picture library. Dit project zal geen specifieke Silverlight componenten bevatten. Het project zal echter wel gereferenced worden vanuit het Presentation.SilverlightUI project. Daarom zal het project toch aangemaakt worden als een Silverlight Application project. Je kunt namelijk vanuit een Silverlight project alleen maar referencen naar andere Silverlight projecten. Het Silverlight project wordt immers op de client uitgevoerd en heeft alleen de beschikking over de Silverlight runtime. Je kunt dus niet referencen naar een project dat gebruik maakt van de volledige.net runtime. De naam van het project zal Data.ServiceAgents zijn. Ook voor dit project geldt dat er een testpagina aangemaakt moet worden in het Presentation.WebPartUI project. Na het aanmaken van het project kunnen zowel de Page.xaml als de App.xaml files uit het project verwijderd worden, omdat dit project alleen data access zal verzorgen. Het vierde en laatste project dat aangemaakt moet worden is wederom een Silverlight Application project met de naam Business.Entities. Dit project zal alleen de assembly file als deliverable hebben en er hoeft voor dit project dan ook geen testpagina aangemaakt te worden. Dit heeft te maken met het feit dat er geen.xap package gedeployed hoeft te worden, maar alleen maar een.dll file die gereferenced wordt door het Presentation.SilverlightUI project. Ook in dit project kunnen dus de Page.xaml en de App.xaml files na het aanmaken weer verwijderd worden. Hiermee is de volledige structuur in Visual Studio opgezet. De projecten zijn als volgt over de drie lagen van het three layered application pattern verdeeld: Presentation => Presentation.WebPartUI en Presentation.SilverlightUI Business => Business.Entities Data => Data.ServiceAgents De volgende stap is het schrijven van de code! Fig. 4: Het aanmaken van het Presentation.SilverlightUI project De code Presentation.WebPartUI We beginnen met het schrijven van de code voor het web part. Hiervoor maken we in het Presentation.WebPartUI project een nieuwe class aan met de naam SilverlightWebPart.cs. De class zal overerven van System.Web.UI.WebControls.WebParts.WebPart. In de OnLoad functie wordt de ScriptManager aan de pagina toegevoegd. magazine voor software development 29

30 INFORMATION WORKER UX protected override void OnLoad(EventArgs e) { base.onload(e); // Script manager instance may appear only once on a page ScriptManager scriptmanager = ScriptManager.GetCurrent(Page); if (scriptmanager == null) { scriptmanager = new ScriptManager(); Controls.Add(scriptManager); } } Business.Entities De volgende stap is het aanmaken van een class MyPhoto in het Business.Entities project. In deze class creëren we één entity met twee properties: Url en ThumbUrl. Doordat de class gebruik maakt van het.net Framework 3.5 kunnen we hier gebruik maken van de automatic properties mogelijkheden van C# 3.0. Hierdoor kan deze code in twee regels geschreven worden. public string Url {get; set;} public string ThumbUrl {get; set;} Listing 4: MyPhoto entity Listing 1: Toevoegen van de ScriptManager aan de pagina Maak een property DataSource aan die gebruikt wordt om aan te geven of het web part foto s moet tonen uit een SharePoint picture library of van Flickr. private string _datasource = "SharePoint"; /// <summary> /// Wwebpart property to determine data source of pictures /// </summary> /// <value>the datasource</value> [WebBrowsable(true)] [Category("Web Part Settings")] [WebDisplayName("Data Source")] [WebDescription("The data source of the pictures.")] [Personalizable(PersonalizationScope.Shared)] public string DataSource { get { return _datasource; } set { _datasource = value; } } Listing 2: DataSource Web Part property Gebruik vervolgens de CreateChildControls functie om het Silverlight control te laden. De _datasource property wordt meegegeven aan het Silverlight control met behulp van de InitParameters property van het Silverlight control. Hiermee is de code voor het Presentation.WebPartUI project al klaar! protected override void CreateChildControls() { // instantiation of the silverlight control Silverlight silverlightcontrol = new Silverlight(); silverlightcontrol.id = "SilverlightWebpart"; silverlightcontrol.source = /wpresources/macaw.iws.moss2007.silverlightdemo. Presentation.WebPartUI/WebPart- Macaw.IWS.Moss2007.SilverlightDemo/ClientBin/ Silverlight.UI.xap"; silverlightcontrol.width = new System.Web.UI.WebControls.Unit(100, System.Web.UI.WebControls.UnitType.Percentage); silverlightcontrol.height = new System.Web.UI.WebControls.Unit(600); silverlightcontrol.initparameters = String.Format("DS={0}", _datasource); Presentation.SilverlightUI In het Presentation.SilverlightUI project moeten we nog een klein stukje ondersteunende logica schrijven. Open hiervoor App.xaml.cs. Deze file wordt aangemaakt op het moment dat het Silverlight Application project wordt aangemaakt en bevat logica voor bijvoorbeeld het starten van de Silverlight applicatie. In de Application_StartUp functie voegen we wat code toe voor het initialiseren van de DataSource parameter die we meegegeven hebben vanuit het Presentation.Web- PartUI project. Deze functie zorgt er nu voor dat de constructor van de Page.xaml.cs pagina wordt aangeroepen met de datasource als parameter. private void Application_Startup( object sender, StartupEventArgs e) { string datasource = null; if (e.initparams!= null && e.initparams.count > 0) { datasource = e.initparams["ds"]; } this.rootvisual = new Page(dataSource); } Listing 5: Het initialiseren van de datasource parameter Ga nu naar de Page.xaml control in het Presentation.SilverlightUI project. Hierin staat standaard al een grid gedefinieerd. Deze kunnen we gewoon laten staan, we halen alleen de breedte en de hoogte van de grid weg. Vervolgens voegen we twee rijen toe aan de grid, de onderste rij is 110 pixels hoog, de bovenste rij zal zo hoog zijn als dat nodig is. Vervolgens voegen we aan de onderste rij een ListBox toe waarin we de collectie van thumbnails horizontaal weergeven. Aan de bovenste rij voegen we een Image toe voor het weergeven van een grote foto. De hoogte van de Image is 350 pixels, dus de bovenste rij zal een hoogte van ongeveer 350 pixels krijgen. Figuur 6 is een schematische weergave van de opbouw van het web part. De bedoeling is dat als je op één van de thumbnails in de onderste listbox klikt, deze vergroot weergeven wordt in de bovenste rij. } Controls.Add(silverlightControl); Listing 3: Het laden van het Silverlight control Fig. 6: Schematische weergave van het web part 30 MAGAZINE

31 INFORMATION WORKER UX <UserControl x:class="presentation.silverlightui.page" xmlns=" xaml/presentation" xmlns:x=" <Grid x:name="layoutroot" Background="White"> <Grid.RowDefinitions> <RowDefinition Height="*"/> <RowDefinition Height="110"/> </Grid.RowDefinitions> <ListBox x:name="listphotos" Grid.Row="1" SelectionChanged="listPhotos_SelectionChanged"> <ListBox.ItemTemplate> <DataTemplate> <StackPanel Orientation="Horizontal"> <Image Source="{Binding ThumbUrl}" Width="120" Height="80" /> </StackPanel> </DataTemplate> </ListBox.ItemTemplate> <ListBox.ItemsPanel> <ItemsPanelTemplate> <StackPanel Orientation="Horizontal"/> </ItemsPanelTemplate> </ListBox.ItemsPanel> </ListBox> <Image x:name="detailimage" Grid.Row="0" Height="350" /> </Grid> </UserControl> GetItemsFromFlickr flickrproxy = new GetItemsFromFlickr(); flickrproxy.getitemsfromflickrprofile(photos => listphotos.itemssource = photos); } } private void listphotos_selectionchanged(object sender, SelectionChangedEventArgs e) { MyPhoto photo = (MyPhoto)listPhotos.SelectedItem; BitmapImage bmi = new BitmapImage(new Uri(photo.Url)); detailimage.source = bmi; } Listing 7: Page.xaml.cs logica Data.ServiceAgents In het Data.ServiceAgents project voegen we een Service Reference toe die verwijst naar de SharePoint list web service. Om deze reference toe te kunnen voegen moeten we tijdelijk Anonymous Access op de web applicatie toestaan. Dit is in te stellen in IIS door rechts te klikken op de web site van de SharePoint web applicatie en vervolgens naar het tabje Directory Security te browsen. Hier klik je op de Edit button onder Authentication and access control. Check vervolgens de Enable anonymous access checkbox. Nu kun je de service reference naar /lists.asmx aanmaken. Visual Studio zal nu een proxy class genereren die de functies van de web services beschikbaar stelt. Listing 6: Page.xaml In de Page.xaml.cs wordt getest of de datasource die gebruikt moet worden voor het laden van de foto s SharePoint of Flickr is en aan de hand daarvan wordt bepaald waar de foto s opgehaald moeten worden. De parameter die meegegeven wordt aan de functies GetListItems- FromSharePoint en GetItemsFromFlickrProfile is een Lambda expressie. Een Lambda expressie is een functie die geen naam heeft, oftewel een anonieme functie, die wordt toegekend aan een variabele. Via deze variabele is de Lambda expressie dan aan te roepen. In dit geval wordt de functie GetListItemsFromSharePoint aangeroepen met de Lambda expressie, maar als je naar de definitie van GetListItems- FromSharePoint gaat zie je dat de parameter een Action delegate is die als argument een IEnumerable van MyPhotos mee krijgt. Meer informatie hierover vind je bij de uitleg van de code uit het Data.ServiceAgents project. Tenslotte bevat deze class een eventhandler die ervoor zorgt dat de thumbnail die geselecteerd wordt als grote foto weergegeven zal worden. public Page(string datasource) { InitializeComponent(); if (datasource == "SharePoint") { GetItemsFromSharePointList sharepointproxy = new GetItemsFromSharePointList(); sharepointproxy.getlistitemsfromsharepoint(photos => listphotos.itemssource = photos); } else if (datasource == "Flickr") { Fig. 7: Het toevoegen van de referentie naar de SharePoint list web service De volgende stap is het toevoegen van de class GetItemsFromSharePointList aan het Data.ServiceAgents project. In deze class maken we een private Action delegate aan en een functie voor het ophalen van de data uit SharePoint met behulp van de list web service. Omdat het web part de foto s ophaalt met behulp van een call naar een web service zal het ophalen van de foto s asynchroon zijn. Met behulp van de Action delegate _processphotos specificeren we wat er moet gebeuren nadat de foto s opgehaald zijn. Omdat het web part de foto s ophaalt met behulp van een call naar een web service zal het ophalen van de foto s asynchroon zijn magazine voor software development 31

32 INFORMATION WORKER UX Een delegate in C# is ongeveer hetzelfde als een pointer in C of C++. Een delegate houdt een referentie naar een functie vast. Als de delegate wordt meegegeven als parameter van een functie kan de vanuit die functie door de delegate onthouden functie aangeroepen worden. Een Action delegate is een soort void functie die geen return waarde heeft, maar die alleen een actie uitvoert. De actie kan gedefinieerd worden als een functie die aangeroepen wordt, maar ook als een Lambda expressie. In dit geval roepen we de functie GetListItemsFromShare- Point in de Page.xaml.cs van het Presentation.SilverlightUI project aan met een Lambda expressie als parameter. We hebben deze variabele nodig om tijdens het uitvoeren van de asynchrone actie te onthouden welke code er uitgevoerd moet worden als de asynchrone actie klaar is. private Action<IEnumerable<MyPhoto>> _processphotos; /// <summary> /// Start an asynchronous service call to get my photos /// and register a callback method to process the result /// when it comes in. /// </summary> /// <param name="processphotos">a method that takes /// one parameter - a collection of MyPhoto - and no result ///</param> public void GetListItemsFromSharePoint( Action<IEnumerable<MyPhoto>> processphotos) { _processphotos = processphotos; ListsSoapClient proxy = new ListsSoapClient(); proxy.getlistitemscompleted += proxy_getlistitemscompleted; // Build XML elements for querying SharePoint list XElement fieldref = new XElement("FieldRef"); fieldref.setattributevalue("name", "Created"); fieldref.setattributevalue("ascending", "FALSE"); Dit houdt in dat op dit moment de ItemSource van de listphotos uit de Page.xaml.cs in het Presentation.SilverlightUI project zijn waarde krijgt toegekend. Ik zal in dit artikel niet de volledige code voor het ophalen van de data van Flickr weergeven. De manier waarop het ophalen van data van de Flickr site werkt is vrijwel gelijk aan de manier waarop je data uit een SharePoint picture library ophaalt. Het belangrijkste verschil zit hem in het feit dat je een andere web service aanroept (namelijk die van Flickr en niet de SharePoint list web service) en dat de XML die de web service terug geeft er iets anders uit ziet. De volledige solution is te downloaden op de SDN web site. private void proxy_getlistitemscompleted( object sender, GetListItemsCompletedEventArgs e) { if (e.error!= null) { MessageBox.Show(e.Error.ToString()); } else { XElement result = e.result; var photos = from x in result.elements().first().elements() select new MyPhoto { Url = x.attribute("ows_encodedabswebimgurl").value, ThumbUrl = x.attribute( "ows_encodedabsthumbnailurl").value }; _processphotos(photos); } } Listing 9: LINQ query om de foto en thumbnail urls uit de resultaten te halen XElement orderby = new XElement("OrderBy", fieldref); XElement query = new XElement("Query", orderby); XElement viewfields = new XElement("ViewFields"); XElement queryoptions = new XElement("QueryOptions"); proxy.getlistitemsasync( "Barcelona", "", query, viewfields, "10", queryoptions, ""); } Listing 8: Asynchroon ophalen van data uit de SharePoint picture library De list items worden opgehaald met behulp van de GetListItemsAsync methode. In de parameters wordt de naam van de lijst (in mijn geval Barcelona), de sortering (in het Query element) en het maximum aantal records dat er teruggegeven moet worden (10) meegegeven. Op het moment dat alle list items zijn opgehaald zal de eventhandler GetListItemsCompleted afgevuurd worden. Hiermee wordt de functie proxy_getlistitemscompleted aangeroepen. In deze functie worden met behulp van een eenvoudige LINQ query de juiste waarden aan de velden in de MyPhoto entity toegewezen. Bij een SharePoint picture library geldt dat de url van de foto is opgeslagen in het ows_encodedabswebimgurl veld en dat de url van de thumbnail is opgeslagen in het ows_encodedabsthumbnailurl veld. Vervolgens wordt de Action delegate uitgevoerd met als paramater de IEnumerable van de MyPhoto entities om de binnen gekomen foto s te gaan verwerken. Deployment Als je al deze stappen hebt uitgevoerd is je code klaar om gedeployed te worden. Het gaat voor dit artikel te ver om uitgebreid te beschrijven hoe deze componenten in een SharePoint Solution package verpakt kunnen worden. Meer informatie hierover is te vinden online te vinden: Wel zal ik aangeven welke files er gedeployed moeten worden en waar deze dan terecht zouden moeten komen. De web part assembly, Presentation.WebPartUI.dll, moet gedeployed worden naar de bin directory van de web applicatie. In mijn geval is het path C:\Inetpub\wwwroot\wss\VirtualDirectories\moss2007dev\bin. De assembly kan ook naar de GAC gedeployed worden, maar dat is geen best practice. De Silverlight controls moeten naar de ClientBin gedeployed worden. Deze zou op diverse plekken kunnen staan, maar ik zal hem uitrollen naar de wpresources folder van de web applicatie C:\Inetpub\wwwroot\wss\VirtualDirectories\moss2007dev\wpresources\SilverlightFotoWebPart\ClientBin. De Silverlight controls zijn ingepakt in de Presentation.SilverlightUI.xap file. Dit is eigenlijk een zip file. Als je de file hernoemt naar.zip kun je de inhoud ervan bekijken. Als een gebruiker een pagina opvraagt met een Silverlight control zal het.xap bestand gedownload worden naar de computer van de gebruiker. Vervolgens zal de Silverlight plug in die op de computer van de gebruiker geinstalleerd is de.xap file uitpakken. 32 MAGAZINE

33 Voor het SilverlightFotoWebPart hebben we alleen de Presentation.SilverlightUI.xap file nodig, deze bevat - Business.Entities.dll - Data.ServiceAgents.dll - Presentation.SilverlightUI.dll Tenslotte moet alleen nog het automatisch aangemaakte Silverlight.js file gedeployed worden. Deze wordt uitgerold naar de wpresources folder van de web applicatie, dus naar C:\Inetpub\wwwroot\wss\VirtualDirectories\moss2007dev\wpresources\SilverlightFotoWebPart. Als de files naar de juiste locatie gedeployed zijn kun je het web part toevoegen aan een pagina in de SharePoint omgeving en het resultaat uit figuur 8 hieronder bewonderen! Mirjam van Olst Mirjam van Olst werkt als Share- Point Technology Consultant voor het Information Worker Solution Center bij Macaw. Zij heeft in de afgelopen 4 jaar aan diverse Share- Point implementaties gewerkt. Op dit moment werkt zij als SharePoint Architect aan een aantal projecten met MOSS 2007, waaronder een intranet voor een grote verzekeringsmaatschappij in Nederland. Daarnaast geeft Mirjam regelmatig presentaties en schrijft zij artikelen over MOSS 2007-gerelateerde onderwerpen. Delphi TIP: INFORMATION WORKER UX Unicode Console Output Delphi 2009 ondersteunt Unicode, maar console I/O ondersteunt alleen AnsiStrings. Toch kun je ook daarmee Unicode strings naar de console schrijven, als je de string eerst omzet naar UTF-8 (een Ansi- String met een variabele aantal (tussen 1 en 4) bytes per teken). Dit kan bijvoorbeeld als volgt: program ConsoleUTF8; {$APPTYPE CONSOLE} uses Windows, SysUtils; begin SetConsoleOutputCP(65001); WriteLn(Output, UTF8String('[наименование проекта]')); readln end. Je zal wellicht niet meteen cyrillic tekens zien: die zie je namelijk alleen als je in het console window Lucida Console als font gebruikt. Het is niet noodzakelijk om te beginnen met de UTF-8 BOM, maar dat kan wel zinvol zijn als je de console output in een bestand wilt "opvangen" en later wilt bewerken. Anders kan de BOM achterwege blijven. Fig. 8: Het resultaat, het Silverlight foto web part magazine voor software development 33

34 Advertentie Microsoft

35 Advertentie Microsoft

36 FULL-COLOUR 5 0 c y a a n g e e l 5 0 z w a r t 1 5 c y a a n BEELDMERK DIVISIES CORE SYSTEMS Frida Robben HP NonStop: 30 Jaar Ontwikkeling in NonStop Transactieverwerking HP NonStop computers hadden al een heel leven lang gedraaid onder de naam Tandem Computers, voordat ze door HP werden ontdekt. En dat was niet zomaar een ontdekking: het hele datacenter van HP wereldwijd is inmiddels volledig uitgerust met deze bijzondere, krachtige machines. Maar wat maakt deze HP NonStop computers dan zo bijzonder? Vanwaar deze aparte naam? En waarom is software ontwikkelen op een HP NonStop zo ontzettend leuk om te doen? Om de eerste vraag te beantwoorden moeten we echt even terug naar het begin: in 1974 is al de basis gelegd voor de huidige NonStop computers. Natuurlijk waren ze nog niet zo snel en efficiënt als de huidige versies, maar de grondleggers hadden in die tijd al zeer goede ideeën over hoe de computer moest functioneren: ze moesten continu beschikbaar zijn, de data-integriteit moest gegarandeerd kunnen worden, de performance moest onder verschillende omstandigheden goed blijven en er was nagedacht over het beveiligen van gegevens. Kortom, ideeën die hun tijd ver vooruit waren! Één nadeel: ze waren kostbaar. Dat maakte dat de doelgroep zich beperkte tot de bankwereld en de grote industrie die ze inzetten om de eerste stappen in elektronische transactieverwerking te zetten voor de effectenhandel en de salarisverwerking. 20 jaar aaneengesloten aan De naam NonStop komt voort uit het gegeven dat ze continu beschikbaar moeten zijn en wie denkt dat dit een loze belofte is, heeft het mis: er zijn behoorlijk wat NonStop computers die pas na 20 jaar vervangen zijn en in de tussentijd niet uit geweest zijn. Ze hebben met recht de naam NonStop. HP NonStop feiten: : De eerste NonStop computer wordt verkocht aan de Citybank : Bij de US Treasury Department verwerkt een NonStop computer wekelijks voor US$10 miljard aan financiële transacties Fouttolerantie Een van de redenen dat ze vol continu aan kunnen blijven is het dubbel uitvoeren van de meest essentiële hardwareonderdelen. Ook wordt gebruik gemaakt van fouttolerantie, waarbij het mogelijk is om in een van de hardwareonderdelen in een vroeg stadium een probleem te signaleren en dit aan te merken als single point of failure. Daarop wordt dit onderdeel vervangen terwijl het systeem blijft draaien. Het mag duidelijk zijn dat dit single point of failure een belangrijk gegeven is: wanneer het systeem op twee plaatsen tegelijk in de hardware een failure constateert zal het systeem geen garanties meer kunnen geven dat het blijft draaien. Dit komt overigens zo weinig voor dat op de huidige HP NonStop computers een beschikbaarheidgarantie van meer dan 99,998% afgegeven wordt. Data-integriteit En dan het onderwerp dat al dichterbij software-ontwikkeling komt: de veiligheid van gegevens en de data-integriteit. Deze waren vanaf de eerste NonStop computer al een belangrijk onderwerp. Zo belangrijk zelfs dat het operating system niet voor niets de naam Guardian kreeg en de tool TMF (Transaction Management Facility) ontwikkeld werd. HP NonStop feiten: : Nasdaq gebruikt NonStop computers voor securities transaction processing : Tandem introduceert de eerste fault-tolerant SQL database, NonStop SQL Binnen het Guardian-OS zijn diverse tools beschikbaar: SAFECOM voor toegangsbeveiliging, FUP als File Utility, TEDIT om te editen, INSPECT om te debuggen, SPOOLCOM voor outputafhandeling, SCUP voor het beheer van de schermlayouts en zo is er nog een aantal tools die standaard bij een NonStop computer horen. Transaction Management Facility Zo ook TMF, dat een speciale plaats inneemt: met deze tool worden transacties vanaf binnenkomst tot aan de bevestiging gecontroleerd verwerkt. Op elk moment tijdens die verwerking kan zo nodig een transactie ongedaan gemaakt worden door een transactie-rollback. TMF en programmeertalen Vanuit elke ontwikkeltaal die beschikbaar is op een NonStop systeem kan TMF aangeroepen worden. Een transactie kan goed eindigen, of abnormaal eindigen, waarna een rollback gedaan wordt om de wijziging ongedaan te maken, zoals in dit COBOL-voorbeeld hieronder: E0020. READ INPUTFILE MOVE INPUTFILE.KEY TO ACCOUNT.KEY READ^FILE ACCOUNT IF READ-OK BEGIN-TRANSACTION IF INPUTFILE.AMOUNT < 0 SUBTRACT INPUTFILE.AMOUNT FROM ACCOUNT.BALANCE WRITE^FILE ACCOUNT IF WRITE-OK END-TRANSACTION ELSE ABORT-TRANSACTION END-IF END-IF END-IF E0099. Listing 1: COBOL TMF-voorbeeld Transactie = wijziging patiëntendossier Maar wat wordt er onder een transactie verstaan? Het hoeft namelijk 36 CONFERENCE MAGAZINE EVENTS

37 niet per definitie financieel te zijn. Een transactie kan ook heel andere gegevens omvatten, b.v. gevoelige overheidsdata of data over energieverbruik per huishouden in een energiebedrijf, patiëntengegevens in een ziekenhuis, of de afhandeling van de logistiek van een vervoersmaatschappij. Het beeld dat alleen financiële instellingen met een NonStop computer werken is daarmee achterhaald. En juist in de huidige internationale bedrijfsontwikkeling waarbij internet en een beschikbaarheid van 24 uur per dag erg belangrijk geworden is, is HP NonStop een uitkomst. HP NonStop feiten: : NonStop Java beschikbaar op NonStop computers vanaf versie NonStop Kernel : Intel Itanium processor in NonStop Dagelijks miljoenen gebruikers Het is erg aannemelijk dat de meeste mensen bijna dagelijks, zonder het te weten, gebruik maken van HP NonStop: vrijwel alle betaal- en geldautomaten in Nederland staan in verbinding met een HP NonStop computer en de meeste telebankierschermen van de verschillende banken werken op HP NonStop. Hieruit kun je concluderen dat Java inmiddels veel gebruikt wordt op deze computer, in combinatie met de verschillende HP NonStop tools. HP NonStop feiten: : Compound Statements in SQL : HP NonStop connectivity products voor databaseconnecties naar ODBC en JDBC Programmeertalen Op een HP NonStop kun je programmeren in de talen COBOL, C/C++, SQL en JAVA. Tevens is er een native taal beschikbaar TAL met libraries waarin standaard TAL-routines zijn opgeslagen voor allerlei standaard werkzaamheden, zoals READ^FILE en WRITE^FILE. SQL en Java op HP NonStop Om gebruik te kunnen maken van Java in combinatie met SQL-tabellen hoef je binnen Java alleen maar een referentie te leggen naar de standaard SQL-class met een select-commando: import java.sql.*; Statement mystatement = myconnection.createstatement(); // De select kan nu uitgevoerd worden en // het resultaat gaat naar object r: ResultSet r = mystat.executequery( "SELECT * from $DATA1.DBASE.EMPL"); // het resultaat is een String dat op het // beeldscherm gedisplayed wordt: while (r.next()) System.out.println("Column 1: " + r.getstring(1)); AutoTMF NonStop AutoTMF is een verlengstuk van TMF, waarbij applicaties ook worden beschermd die zelf oorspronkelijk niet TMF aanroepen. AutoTMF werkt erg simpel: tijdens de verwerking van het programma dat geen TMF aanroept, is AutoTMF op de achtergrond aan het monitoren wat het programma aan het doen is. Als zo n programma naar een audited file of database gaat schrijven, start AutoTMF een automatische transactie. Als het programma naar een niet-audited file of database schrijft, doet AutoTMF niets. AutoTMF en Java Om door middel van Java databasemutaties in een SQL/MX database te doen moet je een class aanroepen: com.tandem.tmf.current, of de Java Transaction API (JTA). Je kunt de default API-TMF gebruiken voor Java transactie-verwerking door middel van een referentie naar UserTransaction, welke gebaseerd is op TMF: import javax.transaction.usertransaction; import com.tandem.jta.jtafactory; // Referentie naar UserTransaction UserTransaction utx = JTAFactory.getUserTransaction(); // Start transaction utx.begin(); // Do work // Commit transaction utx.commit(); Listing 3: TMF gebaseerde transactieverwerking Zelf aan de slag? Als je zelf Java op een HP NonStop wilt proberen, maar je werkt niet op een HP NonStop computer, dan heb je nu de mogelijkheid om het te simuleren! Met de plugin Eclipse HP NonStop kun je simuleren dat je gebruikt maakt van HP NonStop Java met SQL en TMF. De plug-in is te downloaden van de website van HP, installeer deze en neem een kijkje in de wereld van HP NonStop! Er zijn 3 stappen voor nodig: 1: Download en installeer Cygwin, een Linux-like omgeving, vanaf 2: Download de HP NonStop Eclipse plugin vanaf de website van HP: ProductInfo.do?productNumber=HSB99V1 3: Installeer de plugin: zie de afbeelding hieronder. Listing 2: JAVA op NonStop Frida Robben Fig. 1: Anno 2008 NonStop AutoTMF Frida Robben werkt als Technology Specialist voor Sogeti Nederland. Zij heeft ruim 20 jaar ervaring met het werken op HP NonStop machines in verschillende bedrijven, met name in een bankomgeving. magazine voor software development 37

38 FULL-COLOUR 5 0 c y a a n g e e l 5 0 z w a r t 1 5 c y a a n BEELDMERK DIVISIES.NET DATABASES Julia Lerman ADO.NET Entity Framework Overview A few years ago, Microsoft s Data Access team began showing developers a new direction for ADO.NET, the Entity Framework. This new framework, released in August 2008 as part of Visual Studio 2008 SP1, brings data modeling into the hands of the developers. This version of the Entity Framework is the beginning of a long-term strategy for ADO.NET, and part of a larger data access and modeling strategy for Microsoft s applications in general. This article aims to give readers an overview of the ADO.NET Entity Framework, its benefits and some of its current pitfalls as well as an understanding of where the current version fits into the larger picture. Data modeling vs. the database Typically, developers must interact directly with the database to get data into and out of the application. This means that you need to have a fairly good understanding of the structure of the database - its tables, views and stored procedures, constraints, schemas and data types, required parameters for stored procedures and the schema of the data that will be returned. Once you have gotten past this barrier, you then need to write plenty of code to reshape the returned data into your application s objects. If you are writing an application where users can modify data, you then have to extract property values from objects and related data in order to send them back to the data store. By having a data model at the application level that better represents your business domain objects, the developer can focus on application development, rather than on interacting with the database. The ADO.NET Entity Framework differs from these ORMs in a number of ways. To begin with, Entity Framework was created so that developers could program against not just any data model, but an Entity Data Model (EDM). The EDM is Microsoft s realization of Entity Relationship Modeling which has been around for over 35 years. The critical word in there is relationship. ERM and EDM define a model by its entities and its relationships. The relationships are first class citizens in this model rather than being metadata about how entities relate to one another. Another critical difference is how Entity Framework is able to move from the conceptual model to the database and back. The Entity Data Model in Entity Framework Entity Framework uses an Entity Data Model along with additional metadata that enables your program to automatically figure out how to move between objects expressed using the model and the database. Entity Framework includes a set of Visual Studio design tools, including the Entity Data Model Wizard. This wizard allows you to quickly create a model based on an existing database. To demonstrate this, I ll use a simple SQL Server database as an example, although there are a number of other ADO.NET database providers that now support the Entity Framework (and more that will be released in the future). Figure 1 shows a diagram of the tables in the example database which describes a simple sales system. The focal point is the Person table. A related SalesPerson table provides additional details about those people who are sales people. In the same way, a Customer table provides additional details about those who are customers. There is an Order table that uses foreign keys to link back to the associated Customer and SalesPerson. Additional details about people and customers are stored in the PersonalDetails and CustomerTypes tables. Data modeling at the application level is not a new concept. There are a number of ORM tools available to Visual Studio developers such as nhibernate and ORMapper. Visual Studio s LINQ to SQL is also a modeling tool which works specifically with SQL Server and leverages the LINQ query language built into C# and Visual Basic. The ADO.NET Entity Framework differs from ORMs in a number of ways Fig. 1: Database schema 38 CONFERENCE MAGAZINE EVENTS

39 .NET DATABASES Assuming that you instruct the Entity Data Model Wizard to bring in all of the tables from the database, it will create a data model, shown in figure 2, in your application that looks very similar to the database schema. Fig. 3: Customized Entity Data Model There are many more things that you can do to customize a model, from decorative changes such as renaming or even removing properties, to architectural changes like building in inheritance. Fig. 2: Entity Data Model But looks can be deceiving. If you investigate a bit more closely you may notice that each entity has a set of scalar properties and a set of navigation properties. And if you look even more closely, you will notice that there are no foreign keys. The Order entity has neither a CustomerID property nor a SalesPersonID property; the Customer entity does not have a CustomerTypeID property. The relationship between one entity and another is not defined by a foreign key, but by a navigation property. The Order entity has a Navigation Property that is a reference to the Customer it is related to. And the Customer entity has an Orders Navigation property that is a reference to the collection of related orders. These are called Navigation Properties because they define how to navigate from one entity to another. From the data model to classes One of the jobs of Entity Framework s designer is to automatically generate classes from the entities in the model. This is the default behavior and can be overwritten in a variety of ways: from writing your own generator to hooking your custom classes into E.F. I ll focus on the default behavior in this article. Each entity becomes a class which inherits from EF s EntityObject class. The EntityObject class provides the entities with the mechanisms they need to plug into the framework. In figure 4, you can see a class diagram showing the Customer entity and its properties along with the properties, methods and interfaces that it inherits from the EntityObject class. Notice that the code generator added a factory method (CreateCustomer) and four change tracking methods to the Customer class. No worries about JOINs What this means is that you don t have to worry about using JOINs to connect entities to one another. Entities are naturally bound to one another as you query, as you work with entity objects and as you send data back to the database. While this EDM is the default data model created by the wizard, there are actually a host of customizations you can do to the model. Figure 3 shows the same model after I have modified it to redefine the Customer and Salesperson entities as derived entities of a Person. You can build inheritance directly into the data model. Additionally, notice in this version of the model that I have combined the Person and PersonalDetail entities into one entity. Even though it points back to two separate tables in the database, I don t ever have to worry about how that works. Whether I am querying data or modifying it and sending updates back to the database, the Entity Framework will take care of mapping my entities back to the database. I have also renamed some of the Navigation properties so that they are more logical. For example, Customer.Orders was originally Customer.Order, but since that property refers to many orders, as defined by the 1 to Many (1:*) relationship, the pluralized name is more logical. Fig. 4: Generated customer entity class with its base EntityObject class and E.F. interfaces With the model and its classes in hand, it s time to look at some Entity Framework programming features. magazine voor software development 39

40 FULL-COLOUR 5 0 c y a a n g e e l 5 0 z w a r t 1 5 c y a a n BEELDMERK DIVISIES.NET DATABASES Querying against the Entity Data Model The Entity Framework provides a number of ways to query against the data model. The original query syntax created for this purpose is called Entity SQL. Entity SQL is based on standard SQL query languages but has additional features that enable it to work specifically with the Entity Data Model. As with T-SQL, you construct an Entity SQL query expression as a string and then use Entity Framework s query mechanisms to execute the query. When querying, you can return objects or simply stream the data back as a DataReader. Underneath the covers, Entity Framework reads the data model and additional metadata to translate the entities and properties in to their related tables and objects, and then communicates with the specific database provider, e.g., SqlClient, to have the EDM query translated into a store command. Use Entity SQL to return objects or streamed data The Entity SQL language is very rich with over one hundred operators and functions, allowing you to do all of the standard variations on queries whether you are requesting single entities, shaping data with projections, nesting queries or performing joins. Querying against the first version of our example EDM, listing 1 shows a simple query that requests person entities while navigating into the related PersonalDetails entity to express a filter. SELECT VALUE p FROM MyEntities.People as p WHERE p.personaldetails.maritalstatus= Married ORDERBY p.lastname Listing 1: Entity SQL using navigation properties The query in listing 2 uses projection to return shaped data. It begins with Customers, then pulls in the related Person data as well as any Orders that the customer may have. When projection is used, the VALUE keyword is not required. SELECT c, c.person, c.orders FROM MyEntities.Customers as c Listing 2: Entity SQL projection EF has two ways to execute an Entity SQL query. The most typically used is the ObjectQuery which will not only cause the query to execute, but will materialize objects from the resulting data. These objects are instantiated from the classes that were generated from the Entity Data Model. The other mechanism for executing queries is with the EntityClient API which, like other ADO.NET providers, e.g., SqlClient, allows you to create connections and command and return a DbDataReader. In other words, EntityClient returns streamed data and does not materialize objects. This is convenient for tasks such as reporting or moving data around. It differs from using SqlConnections and SqlCommands because the query is expressed in terms of the EDM and the data returned is in the shape of the EDM entities. ObjectQuery execution also uses SQLClient under the covers to execute its queries. LINQ to Entities LINQ (Language INtegrated Query) is an enhancement to C# and Visual Basic that was introduced in Visual Studio When the Entity Framework team first learned about LINQ and saw its querying power, it was obvious that it would be a huge benefit to developers using the Entity Framework. LINQ to Entities is an implementation of LINQ that is particular to working with entities. The entity classes generated from the EDM provide strongly typed classes that allow developers to write queries leveraging strong typing and Intellisense in C# and VB. The following LINQ queries shown in listings 3 and 4, match the Entity SQL examples above. ==VB== From p In MyContext.People _ Where p.personaldetails.maritalstatus= Married Order By p.lastname ==C#== from p in MyContext.People _ where p.personaldetails.maritalstatus== Married order by p.lastname select p Listing 3: LINQ to Entities using navigation properties ==VB== From c In Context.Customers _ Select c, c.person, c, c.person, c.orders ==C#== from c in Context.Customers _ select c, c.person, c.orders Listing 4: Simple LINQ to Entities projection LINQ to Entities queries always materialize objects. Because a LINQ to Entities query is already a query, you don t need to create a separate query object to execute it as you do with Entity SQL. Change tracking and updating Entity objects By default, objects that are created as the result of a query are managed by the Entity Framework s ObjectContext. This context keeps track of modifications not only to the scalar properties, but also to the relationships between objects. The ObjectContext has a SaveChanges method which reads all of the changes as well as any new or deleted objects and sends the appropriate commands to the database to perform updates. If you create new objects under the management of the ObjectContext, it will also take care of relationships. In other words, if you were to create a new Order and a new set of Order Line items in memory, and you specify that the line items are children of that order, the ObjectContext will do the necessary work to automatically insert this graph into the database with the necessary foreign key information. Between queries and updates Retrieving data as entities and saving changes back to the data store is only the surface of what Entity Framework provides. Not only do the EF APIs provide a lot of flexibility to modify the behavior of these critical tasks, but the core of the API enables you to work with the instantiated entity objects in a very granular way. You have the ability to create custom business logic throughout the entity classes, control the behavior of how Entity Framework performs its various operations on the instantiated objects and even control transactions and database connections. For both LINQ to Entities and Entity SQL, there are a number of ways to impact performance, from pre-compiling LINQ queries or caching the Entity SQL s expressions. Using these features means that the expensive task of generating the store query does not need to be repeated. You can also control how objects are managed by the ObjectContext. Microsoft s vision for Entity Framework is large and long-term 40 CONFERENCE MAGAZINE EVENTS

41 .NET DATABASES Drawbacks of a version one product Microsoft s vision for Entity Framework is large and long-term. What we have currently in Visual Studio 2008 is only the first iteration. There are definitely a lot of things about EF today that make it a challenging product for developers to work with. As the architecture of your application becomes more complex, you will need to invest more in understanding and manipulating EF s underpinnings. Some of the bigger drawbacks in the current version are the limited Stored Procedure support (which should be considered with the understanding that query compilation is one of EF s core features), challenges with change-tracked entities when you need to move them across tiers (ASP.NET, Web/WCF Services), limitations when working with very large models and lack of support for agile and domain driven design. There are also quite a few technical nuances (i.e. gotchas) that you should be aware of so they don t surprise you along the way. For example, users of ORM products, including LINQ to SQL, are accustomed to related objects being loaded automatically and might realize surprising results if they assume that Entity Framework does the same - which it does not. Making assumptions about the behavior of relationships between objects can also get you into a pickle, so it s important to spend some time learning about how methods like attaching, adding and detaching impact the objects. For many, the prospect of working with the EDM and getting ahead of the curve for aligning with Microsoft s data strategy is worth the extra effort that it will take to build large, multi-tiered applications with this technology. And there are plenty of developers who are tackling it and working on V1 deployments. While others have chosen to wait until version 2, where there will be vast improvements in the designer, for stored procedures, for n-tier development and for Domain and Agile developers, they are taking advantage of the lead time to start learning the core concepts and ins and outs of EF. Many are designing applications in a way that they will be able to plug EF in to the data layer when they are ready to embed it into their software. A number of Microsoft tools already lean on Entity Framework, most notable ADO.NET Data Services. You ll also find technologies like ASP.NET Dynamic Data Controls which are able to rely on an EDM and the Entity Framework for its back-end data. As more developers learn and use the Entity Framework, you ll find more and more resources and coding patterns to help you along the way. There are already a lot of resources online and a number of books on Entity Framework at your disposal. Julia Lerman Julia Lerman is the author of O Reilly s Programming Entity Framework and is the leading independent authority on the Entity Framework which she has been using and teaching the technology since its inception. Julie is well known in the.net community as a Microsoft MVP, ASPInsider and INETA Speaker. She is a prolific blogger, a frequent presenter at technical conferences around the world, including DevConnections and TechEd and she writes articles for many well-known technical publications. You can read her blogs at Advertentie 4DotNet

42 FULL-COLOUR 5 0 c y a a n g e e l 5 0 z w a r t 1 5 c y a a n BEELDMERK DIVISIES DevTweet: One of the Boys - Women in Technology DevTweet s zijn de conversaties tussen Marianne van Wanrooij en Sander Hoogendoorn over de (on)zin die IT-ers bezig houdt: Software-ontwikkeling met een knipoog. Regelmatig zullen ook gasten worden uitgenodigd. Volg ze ook op Twitter Suffers from writers block! Have to finish my column for Women in Technology Still struggling with the subject? I handed in my "regular" column - not dealing with WIT. When's the final I woke up this morning with an idea. deadline was 13/4, for columns it's a bit easier. so friday has to do. Too bad we don't have too much time.. we could have co-write it... a man vs. woman kind of thing That would have been cool. We could have set it up in a conversation style, maybe even Twitter style. What if we twittered I like the idea! It can be funny and to the point... (at least every response has to be short :-) Normally my responses are longer - like most women (in IT), let alone exceptions (like I'm an exception?.. I'm not a model developer...but a model's just an imitation of the real If you're an exception, that would be BECAUSE you are indeed a MODEL With your looks it's more likely you'll create an exception with many male developers. A BufferOverflowException A BufferOverflowException? As long as they know how to handle it! And otherwise I will give them more Runtime Maybe that's why there so little female developers? It takes a nerd to understand nerd jokes? Maybe too few female I tried to think of all WIT I've met over the past 20 years. Quite a few. But when it comes to writing code, I can literally count Why are there so few female Girls don't choose an IT education. It's the image (nerd/geeks), thinking it's too difficult, the fact it's male So it's because there's too many men in IT that there's not enough girl That's a rhetorical question..;-) But it is one of the reasons why girls don't choose an technical Rhetorical or not. I guess there are so many men in software development because it's so binary. Not how most women think Would you use the opposite explanation for why there are so few male Studies shows that girls THINK it's too complex and therefore dull. Wrong image... never a dull moment in my work It can t be complexity - women are supposed to be multi-tasking, aren't they? Or, in our case: Although I have to say that the idea of studying with 40 girl nurses to me does not sound very So now you know why I've chosen software development. However, the idea of studying with 50 male nerds is more scary. Marvel Heroes, Hitchhiker's Guide, 42, Star Wars all Thought you chose IT because your sense of humor matches that of male nerds? Think Ghostbusters. You probably dig South Park I love South Park... especially the phrase: Respect my O no, they killed Kenny. My favorite episode is where Cartman hates Family Guy, and the one where Canada is on strike, I chose IT because I like the no nonsense mentality, always learning new things, the creative the high level of expertise and the knowledge sharing (e.g. at events) is awesome. I guess that s the geeky part of No nonsense mentality? You've probably never worked for large consultancy firms... But I agree on the creative And I agree on knowledge sharing - but isn't that a typical female thing? So there should actually be more But on the other hand, it also requires hard logic thinking, something a lot of women are less good at. I think the lack of logical thinking by women is not the biggest problem. The female devs I know are VERY good at I love women that think logical. There should be much more of them - TomTom would definitively go out of Hmm where would that put me... I always get lost when I actually use That's not YOU getting lost, it's TomTom. Developed by male Another problem for most women... lack of confidence.. (and men having too Most men only PRETEND to be self confident. But you knew that, didn't and I thought faking was a women's Woody Allen shouts (when Annie Hall leaves him): "And by the way, I faked all my Makes you wonder what kids of relationship a male and a female nerd would have. Watching Comedy Central, laptops on Oh yeah and quality time through MSN MSN while both on the same sofa, watching South Park and sharing code examples. Actually sounds like lots of Nah I've had a similar experience. only the South Park part didn t add up. Bottom line it didn't work out! One advantage of working as a female developer.. no queues at the bathroom at That's a good one. And of course lots of nerdy developers staring at you like. Don't you get tired of Hmm.. Getting tired of nerdy men looking at me? I wouldn't be a good presenter if that would bother me, now would You're fast. Developers stare at me too when I'm presenting, but I hope that's So concluding you might say that girls do not get into IT because there's too many male I read an article yesterday that stated that certain ant colonies in the US reproduce without sex, no more male ants I feel sorry for those ants So, if Darwin is right, and this ant pattern gets picked up by humans, the problem of too many male developers should soon be developers reproducing by themselves!? Wow... talk about scary! The nurses You can't publish that in SDN Let s find Btw... are you putting this together for the Eh... I thought you were putting this together actually. Ha ha. Typical man / woman I can do it... no probs... Typical female way to solve Haha. I counted on that call it my male Yeah! Sure ;-) 42 CONFERENCE MAGAZINE EVENTS

43 DELPHI Ann Lynnworth The WebHub Way of Thinking In the early days of the world wide web (1994), I was lucky enough to learn HTML from an expert who worked in a makeshift office on the second floor of a warehouse near San Francisco, and CGI-WIN from Robert Denny, the author of WebSite (a great product subsequently side-lined by Microsoft's HTTP-server, IIS). Internet lifetimes have gone by since then, and yet, looking back, some ideas have withstood the trial by fire of Windows OS upgrades, Delphi migrating to CodeGear, Unicode, CSS, the iphone... At HREF Tools in 1995, we created WebHub, a totally-cool, extremely-flexible web development framework for Delphi. I have worn quite a few hats at HREF, but revealing WebHub's secrets has been my passion all along. With this article, I invite you to peek inside the world of WebHub, to learn from our way of thinking about web development with Delphi, and to aim for a better world wide web. Explaining WebHub is a little like showing wire after wire of an intricate structure, hoping that the listener will imagine how they combine together Indeed, WebHub contains many threads (pun intended), or groups of functionality. When taken together, they enable you to create a web application which can carry a New York rush-hour quantity of traffic. You can build anything from off-broadway static sites to Wall Street business-suit applications to Paris cafes. We have a portfolio section on and you are invited to have a look there to see what some of our customers have built over the years, often on small budgets. WebHub sites easily support a million dynamic page requests per day... and more, if you throw more than $2500 worth of hardware at the problem. Fig. 1: Woven strands form cables which suspend the Brooklyn Bridge in New York The observation that I would like to start with is the almost inconceivable strength of individual strands when woven suitably together. For me, this is evident in the Brooklyn Bridge (see figure 1), where each cable is made of 4 main strands, each consisting of 19 wires and, in total, containing over 391km of wire (see ref. 1)! Explaining WebHub is a little like showing wire after wire of an intricate structure, hoping that the listener will imagine how they combine together. Fig. 2: Snail shell magazine voor software development 43

44 FULL-COLOUR 5 0 c y a a n g e e l 5 0 z w a r t 1 5 c y a a n BEELDMERK DIVISIES DELPHI The second metaphor to conjure up appears in figure 2 - the snail - illustrating the notion of slow but steady progress. WebHub evolution may not always go in a straight line, but it moves consistently toward something greater. Similarly, many web sites start in a fairly primitive state, and evolve over time, as the owners become more ambitious and the developers become more skilled. The WebHub framework supports entry-level static sites, simplistic dynamic sites and fullfeatured database-driven sites. Throughout that evolution, WebHub developers can use one syntax, one paradigm, one approach. Over the lifetime of a web site, that saves hundreds of hours and potentially tens of thousands of dollars. Yes, WebHub can help you build static sites with great ease. In the section below on teamwork, there are some examples of re-usable droplets, and page definitions. Any page can be exported to a static file; all pages can be exported by a single verb on the main application object. So while I use WebHub to build dynamic sites for my day job, I also use it to maintain static sites for relatives and friends! Four essential facets Every web application has one job, which is to process requests that arrive over HTTP, calculate the answer and optionally perform any other task(s), and then return that answer in the appropriate format (HTML, CSS, XML, etc.). (A web application as defined for this article is a dynamic web site which probably has database-driven content and may, or may not, look and feel like a Windows application). Let's have a look at four essential facets of WebHub which combine to accomplish that job elegantly and super-fast: teamwork, overall architecture, consistent url with save-state, and Delphi hooks. Teamwork You may have noticed that some people are more left-brained, logical, and methodical than others. An optimized web development team needs one or more left-brained people to write the logic in Delphi (or PHP or C#) and to do the database work. That team also needs some right-brain talent to design the page layout, choose the color scheme, imagine the best user interface, create graphics, logos, and so on. Once in a great while, a single person has strong talent in both areas, but usually, almost always, a web site moves forward best with a team of at least two people. To keep our story simple, consider the left-brained person(s) to be the To keep our story simple, consider the left-brained person(s) to be the Delphi developer and the right-brained person(s) to be the web artist in charge of the HTML Delphi developer and the right-brained person(s) to be the web artist in charge of the HTML. In reality, sometimes the Delphi developer will do a bit of HTML or CSS coding, and sometimes the web artist will offer an observation that leads to better logic. Supporting teamwork means ensuring that each person can do their work without interfering with the other person, and without waiting too long between tasks for some shared resource. To talk concretely, this means dividing up the web site assets into at least two groups of files: one set for the Delphi coder and one set for the web artist. It is then easy to use version control, and everyone can work pretty much in parallel. WebHub, by default, keeps all web page definitions in plain-text files outside the Delphi application. Every detail about the page layout, colors and user interface can be altered without recompiling or even stopping the Delphi application. For any web artist who uses Dreamweaver, we have a custom plugin which provides live content directly in "design mode" - and this means 100% live, 100% accurate content. The web artist can enjoy all the normal benefits of Dreamweaver plus context-sensitive help for editing any WebHub expression, shortcuts for testing, and a built-in reference to all WebHub commands. Most importantly, the web artist can accomplish great things with a fairly minimal understanding of WebHub, components, and database issues, while the Delphi developer can keep the Delphi IDE as home base. Now that we have a file-based territory for each side of the brain, let's talk about iterative development. There are few organizations with the luxury of completely specifying a software project in advance of its commencement. Rather, someone builds a prototype and then features are refined according to priorities and budget. You may be surprised to learn that the syntax in the external files actively assists with iterative development, via the "sketch" tag... this will become clear shortly. WebHub uses its own markup language, which is a superset of HTML, with special tags to mark out pages, reusable droplets, text substitution macros, plus expressions for calls to reusable pieces. This markup language is called WebHub-HTML, or W-HTML for short, and is saved in "teko" files (*.whteko). A WebHub page definition file (*.whteko) can contain any number of page, droplet or macro definitions, in any order. Page attributes can be shared by all, or some, pages within that file. We wanted to convey the idea that our files could contain more than just one web page, and we chose the word 'teko' (from Esperanto, where it means "briefcase") as the keyword. To remember the file extension, think of (WebHub + teko) =.whteko, "a briefcase of declarations." Full documentation about the.whteko file format can be found at Within any page, droplet or macro, you can use a WebHub expression. A few examples will help you get the pattern quickly: (~mchelloworld~) (~wahelloworld.execute~) (~wahello.execute world~) Inside Delphi, you can make use of any WebHub expression by saying pwebapp.sendmacro(name-here); WebHub includes about 35 built-in commands, of which JUMP is the most commonly used. The JUMP command outputs an <a href_tag> to "jump" the surfer to the desired page. Details vary based on configuration settings for the type of HTTP server software and any optional filters. Thus (~JUMP home Home Page~) could generate any of the following, depending on configuration settings, in a web app identified as "a", for the surfer using session number 123: <a href="/scripts/runisa.dll?a:home:123">home Page</a> <a href="/a:home:123">home Page</a> <a href=" Page</a> <a href="/a/home/123">home Page</a> 44 CONFERENCE MAGAZINE EVENTS

45 DELPHI Listing 1 shows a minimalist.whteko file: <!DOCTYPE whteko PUBLIC "-//HREF//DTD whteko stage 2.14//Strict//EN//" " <whteko> <whpage pageid="home"> <html><head> <whdroplet name="drheadtags" show="yes"> <title>(~pageid~)</title> <style type="text/css"> body { font-family:verdana, Arial; } </style> </whdroplet> </head> <body> <p>hello this is a page with id (~pageid~).</p> <p>(~jump home show again~)</p> <p>(~jump clock check server time~)</p> </body></html> </whpage> <whpage pageid="clock"> <html><head>(~drheadtags~)</head> <body> <p>the time on the server is (~CentralInfo.WebTimeLocal~).</p> <p>(~jump clock show again~)</p> <p>(~jump back home~)</p> </body></html> </whpage> </whteko> Listing 1: A WHTEKO file containing two page declarations (home and clock) This.whteko file would be loaded by the WebHub application (compiled in Delphi), and all the content would be available for use when the web pages are served. The relationship between EXEs and AppIDs is many-to-many. A single EXE can load many AppIDs (albeit one at a time). An AppID can be loaded by many EXE instances. To see more examples, you may visit where we have more than 3 dozen WebHub demos. All include full-source (Delphi code plus WHTEKO code). Please feel free to browse through them. Use the [Source] link in the page footer of each demo to explore the source code. All the "lite" demos can be loaded by whlite.exe as they all use the same basic components. In today's world, teamwork often involves players in more than one country, with strengths in different human languages ("lingvos"). Winning web sites cater for visitors from multiple countries and provide content in more than one lingvo. With its full Unicode support within Delphi, Delphi 2009 offers us a tremendous leg up in terms of development for such a multi-lingvo world. We definitely recommend that you use Delphi 2009 if any of your database or other source data is in Unicode format. The WHTEKO files are generally in UTF-8 format; Delphi 2009 users can use UTF-16. Regardless of the Delphi version, WebHub has built-in support for translating content to multiple lingvos. This is ideally done using Dreamweaver, where a translator can set the design-lingvo to their own native lingvo and immediately see how the page would look using their wording. Even without Dreamweaver, a translator can enter translations for words, phrases and entire droplets if needed. On a public site, the application will operate with a default lingvo. For our sites, the default lingvo is English, so any macros or droplets which have not yet been translated will appear in English. Meanwhile all translated content will appear in the surfer's selected lingvo. In Dreamweaver and in the WebHub editor, syntax highlighting makes the code much easier to read. Figure 3 shows a subset of listing 1, with colors, to give you the idea. Fig. 3: Part of listing 1, showing syntax highlighting within Dreamweaver What to notice in listing 1: 1. A droplet is used to define a portion of the header within the home page. The droplets are called (re-used) on the clock page. 2. Links from one page to another are generated by the JUMP macro as needed at calculation time; see lines 27 and 28 in figure 3. When the target PageID is omitted as in line 28, the default PageID is filled in automatically. 3. The doctype allows content to be validated by suitable programs (including Dreamweaver) 4. Parentils surround WebHub expressions, e.g. (~pageid~) and (~drheadtags~) Fig. 4: WebHub architecture magazine voor software development 45