Fase 3.2

1. Introduction to Visual Studio The tool for Windows phone developers

2. Projects and Solutions

3. Topics Creating and running programs A simple Visual Studio project Assembly files and executable files Visual Studio solutions Linking assemblies The XAP file

4. Program creation Programs are written by programmers using a high level language (for example C#) They are then compiled into a lower level language which then runs Microsoft .NET uses an intermediate language (MSIL) to allow programs to be more portable To create a simple program you just need the compiler to create the compiled code 4

5. .NET Software Development Kit The .NET SDK is a free download: http://msdn.microsoft.com/en-us/netframework/aa569263.aspx It contains the .NET runtime and a command line compiler The compiler takes the source file in and creates an output file that can be run As long as it doesn’t find any errors in the program 5

6. Using the command prompt The compiler provided with Visual Studio can also be used from the command prompt 6

7. Programs and Visual Studio You could write every program you ever want to write using the notepad editor and command prompt compiler But this would be hard work Visual Studio is an “Integrated Development Environment” for creating programs Edit program source Build the solution Debug the solution 7

8. Visual Studio Visual Studio is a complicated beast to use But you don’t have to press all the buttons at the start 8

9. Projects and Solutions The first thing we are going to look at is how Visual Studio organises things for us We are going to start with a look at the Visual Studio project To do this we are going to create a very simple project which just contains one program file and runs at the command prompt 9

10. Demo 1: Creating a Simple Project Demo 10

11. The Empty Program using System;usingSystem.Collections.Generic;usingSystem.Linq;usingSystem.Text;namespaceSimpleProject{classProgram {staticvoid Main(string[] args) { } }} 11

12. Using multiple source files If we want to write a simple console application we now know how to do it We could add new methods to the Program class and new classes to the source file However, we often want to spread a development over several source files This allows us to reuse code and also work independently from each other 12

13. Demo 2: Adding a new class Demo 13

14. Projects and source files namespaceSimpleProject { classProgram { staticvoid Main(string[] args) { Library l = newLibrary(); } } } We can now use the Library class in our main program 14

15. Projects and Namespaces The Main method can use the Library class directly because they are both in the same namespace A namespace is a way you can logically group code together Stops programmers getting name clashes If the namespace of the library class is different from the program the compiler will raise an error 15

16. Demo 3: Creating namespaces Demo 16

17. Adding resources to a project We can add resources to a project These are managed by Visual Studio We can control what Visual Studio does with the resource when the program is built copy the resource to the output directory embed the resource in the program file 17

18. Copying Resources The “Build Action” element of the resource properties tells Visual Studio what to do with the content when the program is built We have told Visual Studio that the bitmap is content and should be copied into the output directory 18

19. Using copied resources Bitmap b = newBitmap("Bitmap1.bmp"); Since the resource is just a file held in the same directory as the program we can load it directly This statement loads the bitmap resource into a bitmap called b The program can then display it 19

20. Embedding Resources If you want to guarantee that a resource can be found you can embed it in the program file It then becomes part of the executable program To do this you change the resource properties 20

21. Using embedded resources Assemblyassembly; StreamimageStream; assembly = Assembly.GetExecutingAssembly(); imageStream = assembly.GetManifestResourceStream("Bitmap2.bmp"); Bitmap b = newBitmap(imageStream); To load the bitmap we now have to get a stream from the assembly resources We can then construct the bitmap from it 21

22. Demo 4: Using Resources Demo 22

23. Programs and Assemblies We have seen that a “program” file can contain resources such as bitmaps This is because in .NET a program file is actually a .NET assembly file An assembly file is a container which can hold a collection of items We can look inside an assembly using the ildasm tool 23

24. ildasm The Intermediate Language Disassembler is a program supplied with the .NET Framework It allows us to look inside assemblies and see what is there It can also show you the Microsoft Intermediate Language (MSIL) statements the compiler produced for your program 24

25. Starting ildasm The ildasm program is a Windows application It runs from the Visual Studio Command line You open the command line from the programs menu: All Programs>Microsoft Visual Studio 10>Visual Studio Tools 25

26. Ildasm in action Ildasm lets you navigate the classes in an assembly The display on the right is our resource display app You can see all the methods in each class The “ctor” method is the constructor for the class 26

27. The Assembly Manifest The assembly contains a manifest section that describes what is inside the assembly You can see the Bitmap2.bmp resource 27

28. Demo 5: Using ildasm Demo 28

29. Creating libraries At the moment we just have a single program However, we can also create library assemblies that can provided behaviours for other assemblies A library assembly is stored in a file with the language extension .dll It does not contain a Main method 29

30. Creating a library A library project is created from the library template in Visual Studio 30

31. Dynamically Loaded Libraries The elements in a library are only loaded when they are used When a method in a class is called the class will be loaded into memory and the Just In Time compiler converts it into machine code for execution This reduces the amount of memory needed by the program and avoids wasting time compiling un-needed code 31

32. System Libraries and References System.Console.WriteLine("Hello World"); A program will make use of system resources as it runs System resources are deployed as dynamically loaded assemblies The system assemblies are held centrally by the operating system in the “Global Assembly Cache” 32

33. System Assembly References The references initially assigned to an assembly are determined by the project template These are the references that are assigned to a simple project You can add others 33

34. Building an application When we build an application Visual Studio creates the assemblies Above you can see these in the output folder This folder also contains debug information which is used by Visual Studio The release version does not include this 34

35. Visual Studio Solutions A Visual Studio solution can contain a number of projects You create additional projects just by adding them to the solution The projects do not need to be the same type You can have multiple executable assemblies in a single solution 35

36. Creating a new project in a solution You can add projects by using right click on the solution in Solution Explorer 36

37. Projects in Solution Explorer This shows a version of SimpleProject that also contains a DisplayLibrary which performs the display The two projects are separate and each produce assemblies One is a library and the other an executable 37

38. Linking Projects Although the projects are in the same solution they are not linked If you want to use the output of one project in another you must add a reference to the project output 38

39. Multi-project build output When we build a multi-project solution all the required assemblies are copied into the output folder The SimpleProject assembly will contain a reference to the DisplayLibrary assembly 39

40. Manifest external references You can use ildasm to find the external assemblies that an assembly uses This is the manifest for SimpleProject 40

41. Demo 6: A Multi-Project Solution Demo 41

42. Windows Phone Solutions A Silverlight Windows Phone solution only contains a single project This contains all the images used for the icons on the phone It also uses all the Windows Phone references 42

43. Windows Phone Solutions An XNA Windows Phone solution contains two projects One of these holds all the assets used by the game itself We can add other projects for Xbox and Windows PC versions 43

44. Windows Phone deployment Before a Windows Phone program can run it must be transferred into the target This can be either a Windows Phone device or the emulator All the content the application requires must be transferred as well Along with any additional assemblies that make up the entire application code 44

45. Output Files for an application These are the files that make up the AddingMachine application These include the images for use for the background, loading screen and icon 45

46. The XAP File The XAP file is a container that holds everything needed to run the application It is a Zip archive with a manifest that describes its contents 46

47. Running the XAP file When you press the “run” button in Visual Studio the XAP file is copied to the target device The device opens the archive, reads the manifest file and starts the application running The XAP file is also the file that is sent to a customer who buys the program in Windows Marketplace 47

48. Review Visual Studio brings together code and assets into a project file that describes an assembly An assembly can be either an executable program or a dynamically loaded library Projects are brought together into solutions If a project wants to use an external library it must explicitly link to this The XAP file contains all the resources and code for deployment to the target device 48

49. Debuggingprograms

50. Topics The Windows Phone emulator Deploying to the emulator Debugging with Visual Studio Adding breakpoints Single stepping code Viewing and modifying variables Using the Immediate Window in Visual Studio Designing code for debugging

51. The Windows Phone Emulator The Windows Phone emulator runs as a program on your Windows PC It contains the same software as a “real” phone, but built for the Windows PC platform The emulator is supplied with the Windows Phone SDK 51

52. Deploying to the Emulator Visual Studio lets you select the target device for your program when it runs The emulator is started the first time you deploy to it It will then remain running until you stop it 52

53. Emulator Features The emulator does not contain the complete Windows Phone experience It does have the browser and will provide the phone behaviours for things like placing calls and sending SMS messages There are also some entries in the Address Book It also contains an emulator of the Windows Phone camera 53

54. Emulator Performance The emulator is not a reliable way of predicting how a program will perform on a real device The processor in a Windows PC may be more powerful than the one in the phone The emulator is for functional testing only If you have any concerns about performance you should ensure you run your program on a real device 54

55. Visual Studio debugging Visual Studio provides an exceptional debugging experience This experience extends to Windows Phone You can do all the debugging actions in Windows Phone that you can do with a Windows PC application Breakpoints Single Stepping Viewing and modifying variables 55

56. Breakpoint You set a breakpoint at a statement where you want the program to pause When the program reaches the breakpoint you get control and can take a look at what the program is doing You can set breakpoints even when the program is running 56

57. Setting a Breakpoint To set a breakpoint just double click in the left margin of the statement The statement is highlighted to indicate that a breakpoint has been set 57

58. Hitting a Breakpoint The next time the statement is obeyed the program will break The statement at the breakpoint is highlighted 58

59. Viewing Variable Contents You can view the contents of a variable in the program by resting the cursor on the variable name in the code You can also select variables to watch 59

60. Single Stepping a program You can step through code a line at a time The current position is highlighted in yellow The statement at the current position has not been executed yet 60

61. Program Control Start or resume the program running Execute a single statement and step into a method call Execute a single statement and step over method calls Exit a method which was stepped into Pause the program Stop the program 61

62. Managing Breakpoints Visual Studio provides a Breakpoint window you can use to manage all the breakpoints you set in a program You can also manipulate the properties of each breakpoint 62

63. The Immediate Window The Immediate Window lets you view and change the values of variables You can even call methods inside your program 63

64. Demo 1: Debugging AddingMachine Demo 64

65. Design for Debug privatevoidcalculateResult(){resultTextBlock.Text = (float.Parse(firstNumberTextBox.Text) + float.Parse(secondNumberTextBox.Text)).ToString();} We could create our entire program behaviour in a single statement However, this makes it much harder to take a look at the intermediate values and find out why our program is failing 65

66. Review The Windows Phone emulator shows the behaviour of the phone but not performance You can set breakpoints in your Windows Phone programs to stop code at particular statements You can view the contents of variables in the program You can also view and modify program variables using the Immediate Window 66

67. Exercise1: Buildingthe time trackeruser interface

68. Exercise 2: debugging a brokenprogram