Windows Phone Guide for Android Application Developers Table of Content
Download 0.57 Mb.
|
- Navigate this page:
- A Comparison between C and Java Features
- Methods with Multiple Parameters
- Instance vs. Class Level Access
- Object Lifecycle: Creation and Deletion of Objects
- Type Checking vs. Reflection
Managed ProgrammingWindows Phone 8 supports managed programming in C# or VB as well as C++. In this chapter, we will only look at C# and compare it with Java. Before we jump into the details of C#, let us briefly review the .NET programming environment. 
Figure Managed Application Execution Flow The C# compiler (and similarly, the VB compiler) compiles the C# (or VB) code in an intermediate language (IL) byte code and metadata. The Common Language Runtime (CLR) executes the byte code. C# uses metadata to manage type safety, exception handling, and run-time validations such as checking array bounds . The CLR also manages memory and performs garbage collection. This is similar to Android where the Java code is compiled into a .dex file which is then executed by the Dalvik VM. A Comparison between C# and Java FeaturesThere are many many similarities between Java and C#. They both
However, there are also many subtle and important differences between the two as we will see below. Class DeclarationLike Java, C# does not separate class definition from class implementation. The compiler derives the metadata about the class from the class implementation. As in Java, we can define multiple class definitions in the same file. However, unlike Java, more than one class in a file can be public and the name of the file may be different from the public class in the file. In the example, the public signature of the class Person consists of the age property and the constructor. The rest of the class implementation is opaque. using System; // This is similar to java import except //.NET directives are for the whole namespace namespace FirstApplication // scope for classes. Similar to package in Java // Unlike C#, namespace does not force directory { class Person // Like Java, only uses class defined // implementation not declaration. { private DateTime birthDate; // a private field accessible within this class private int ageOn(DateTime date) // a private method accessible in class { TimeSpan span = date.Subtract(birthDate); //like Java uses a .notation to invoke return span.Days; //Unlike Java, C# supports properties }
public int age //Unlike Java, C# supports properties. { Get // just a getter; it’s a read-only property { return this.ageOn(DateTime.Now); } }
{ birthDate = dob; } }
{ static void Main(string[] args) // main entry point into the program { Person p = new Person(new DateTime(1973,11,12)); //construct an instance System.Console.WriteLine("The age is is" + p.age.ToString()); DateTime dt = p.birthDate; //error in compilation birthDate is private } }
Instead of using the import statement in Java, C# employs a using statement to refer to the metadata of other classes. The namespace declaration that is shown at the top of the file is used to declare the scope, which avoids name conflict and organizes the code. You can access a class in another namespace by referring to its fully-qualified name. See the reference to System.Console.WriteLine in the example above, where console is in the System namespace. Strong TypingBoth Java and C# are strongly typed languages. The types must be specified for variables and input/output parameters1. The compiler enforces the types. In the section on generics, you can see how C# uses strong typing for collection classes. Strong typing works similarly for all classes. The code example below shows the strong typing for primitive types. int a = 5;
Class ConstructorsLike Java, C# uses instance constructors to create and initialize instances. For example: p is an instance of the Person class. You can construct and initialize p with a given birthdate, in a single statement. Person p = new Person(new DateTime(1973,11,12)); PropertiesUnlike Java which has no class properties, C# classes can have properties. Properties provide a natural syntax for accessing members. Properties help to abstract away from directly accessing the members of a class. This technique is similar to using accessors (getters) and modifiers (setters) in Java, but is more natural to read and compact. The properties can be defined as read-only, write-only or read-write. You can make the C# property read-only by providing the getter, write-only by providing the setter, or read-write by providing both getter and setter. In the above example, “age” is implemented as a read-only property since it only exposes a getter and not a setter. You often need to decide whether to implement a member as a property or a method. As a general rule, use properties when you need to access data. To take any action on the data, use methods. Parameter TypesLike Java, C# uses value parameters by default. Parameters that are passed by value cannot be modified in the method. But unlike Java, C# also allows the passing of reference parameters by using the ref modifier. You can pass parameters by ref where you want to change the value of the actual parameter. In some cases, you need to use reference parameters for better efficiency since they avoid data copying. void Foo (ref int x, int y) { x = 0;
y = 0; } .. int a = 5; int b = 8; Foo (ref a, b); //a is zero and b is still 8 C# also provides the parameters with an out modifier. The out modifier represents the parameters that must be initialized by the called method before returning. This design pattern is often used to return the error in addition to the value of the function. Access PrivilegesLike Java, C# allows access privileges for class members. Access privileges can be specified on fields (for example, birthDate), methods (for example, ageOn) and properties (for example, age). C# uses public, private, and protected as modifiers to denote the three different levels of access privileges. In the above example, the compiler gives an error on p.birthDate since that variable is private. Therefore, p.birthDate is not accessible from the Program class. Similarly, the ageOn method is also private and inaccessible from the Program class. Similar to Java, C# protected members are accessible from derived classes. Methods with Multiple ParametersBoth Java and C# support methods with multiple parameters. While C# traditionally uses positional and unnamed parameters, the latest version of C# also includes named parameters. The following example shows the comparative syntax for Java and C#.
Like Java, C# explicitly supports method overloading. Both Java and C# use method name and parameter types for defining method signatures and for differentiating between methods. The following code sample shows how C# differentiates between methods that have the same name. void insert (myClass obj, int index); void insert (myClass obj, myClass before); The method insert may be called with both these signatures: list.insert (myObj1, 4); list.insert ( myInstanceNew, myInstanceOld); InheritanceLike Java, C# uses a single inheritance mechanism. Inheritance is specified by listing the parent class after the class name as shown below. In this example, the class Rectangle inherits from the class Shape, and the class Square inherits from the class Rectangle. class Rectangle : Shape class Square : Rectangle Similar to Java, in C#, the no parameter constructor of the base class is automatically invoked when you construct an instance of a derived class. Similarly, a derived class in C# can invoke a specific constructor of the base class if needed. You can see this in the constructor of the Square class. public Square(double s): base(s, s) //constructor. Calls parent constructor explicitly Unlike Java, a C# derived class may not override a method by just redefining it. The class must use the keyword override in its method definition to explicitly override the definition in the parent class. Override modifier is used to modify the abstract or virtual implementation of an inherited method or property. An abstract modifier is intended to denote that a class, method or property. Members marked abstract or included in an abstract class must be implemented by a derived class. A virtual member denotes that it may be overridden in a derived class. The following code sample shows inheritance and how methods can be overridden in a derived class: using System; namespace SecondApplication { struct Point // In contrast to Java C# provides structs { public double x; // struct fields can also have access modifiers public double y; public Point(double p1, double p2) //a constructor for the struct { x = p1;
y = p2; } } interface IThreeDShape // an interface, like a Java interface { // defines the behavior double volume { get; // Volume is a read-only property. no setter } } abstract class Shape // this class is marked abstract, i.e. may not be instantiated. { protected Point origin; // only derived classes may access. Similar to Java protected variables protected static int counter = 0; // similar to Java class variables public string ID; protected Shape() //a constructor. Same name as the class name { counter++; // class variable being updated } public Point Origin { set
{ origin = value; } }
{ get;
} public abstract bool contains(Point p); // this method must also be overridden }
{ public double length; //field accessible from others public double width; public Rectangle(Point o, double l, double w) //a public constructor { ID = "Rectangle_" + counter.ToString(); origin = o; length = l; width = w; } public Rectangle(double l, double w) // one constructor using another constructor //creates a rectangle at the origin : this(new Point(0, 0), l, w) { }
// unlike Java, overridden method must { // use override keyword get {
} } public override bool contains(Point p) { if ((origin.x < p.x && origin.x + length > p.x) || (origin.x > p.x && origin.x - length < p.x)) if ((origin.y < p.y && origin.y + length > p.y) || (origin.y > p.y && origin.y - length < p.y)) return true; return false; } } class Square : Rectangle { public double side; public Square(double s) : base(s, s) //constructor { ID = "Square_" + counter.ToString(); side = s; } } class Cube : Shape, IThreeDShape //similar to Java, class implements interface { public double side; public Cube(double s) { ID = "Cube_" + counter.ToString(); side = s; } public override double Area { get
{ return 6 * side * side; } }
{ get
{ return side * side * side; } }
… } class SecondProgram { static void printVolume(IThreeDShape tdShape) { Console.WriteLine("The volume is " + tdShape.volume); } static void Main(string[] args) { Rectangle r = new Rectangle(5.0, 3.0); Cube c = new Cube(4.0); SecondProgram.printVolume(c); double a = r.Area; Console.WriteLine("The area of rectangle " + r.ID + " is " + a.ToString()); bool b = r.contains(new Point(1, 2)); Console.WriteLine("The point is in " + b.ToString()); // will print TRUE } }
Protected AccessLike Java, in C#, you can use the protected modifier to limit access to fields, properties, and methods. Protected members are accessible only to derived classes. You can implement protected variables in C# by using the protected access modifier, as shown in the code sample below: protected Point origin; protected static int counter=0;
protected static int counter=0; Abstract ClassesAbstract classes in C# are similar to Java abstract classes in that they cannot be instantiated. The class Shape defined in the above C# code sample is an abstract class. It requires that both the Area property and the contains method must have an override in any derived classes. abstract class Shape { public abstract double Area { get;
} public abstract bool contains(Point p); InterfacesInterfaces are similar in Java and C#. In the sample code shown below, Interface IThreeDShape is implemented by the Cube class. In both languages an Interface defines a contract consisting of method signatures, but no implementations. A class that implements an interface must implement all methods defied in the interface. interface IThreeDShape { double volume { ...
class Cube : Shape, IThreeDShape PolymorphismBoth Java and C# provide polymorphism via class inheritance. A class can be used as more than one type - as its own type, as a base type or as one of the interfaces it implements. You can pass a C# derived class as a parameter to a method that expects a base class. Similarly, if a method expects an interface parameter, you can pass an instance of a class that implements that interface. The following sample code shows how to pass an instance of the class Cube as a parameter, where the method expects an object of the class IThreeDShape. static void printVolume(IThreeDShape tdShape) { Console.WriteLine(“The volume is ” + tdShape.volume); } … Cube c = new Cube(4.0); SecondProgram.printVolume(c); // Since Cube implements IThreeDShape interface, this is legal StructsUnlike Java, C# provides structs as first class language primitives. In C# structs are similar to classes except that they are a value-type. C# structs can use modifiers and can have constructors, methods, and properties. However, a struct does not implement inheritance. struct Point { public double x; public double y; } Object Lifecycle: Creation and Deletion of ObjectsBoth Java and C# performs automatic memory management. Both languages use the new operator to create objects, i.e. class instances, and initialize them. However, unlike C++, neither of them provide object deletion. Objects are automatically ‘deleted’. When the code execution reaches a place where an object is outside the scope, i.e. it can no longer be accessed, the object becomes eligible for garbage collection. In C#, the garbage collection is implemented using .NET. The .NET CLR garbage collector periodically frees up the memory for the objects that are no longer accessible. Unlike C++, developers do not need to ref count objects nor free up unused objects. In rare circumstances, you may need to perform a cleanup at the time that an object is destroyed. C# allows the use of destructors, which are similar to Java finalizers, but in practice this is rare. Type Checking vs. ReflectionReflection is the ability to discover the members of a class and to invoke methods at runtime. Both Java and C# support reflection. You can use reflection to: Get information about the type from an existing object. Dynamically create an instance of a type. Bind the type to an existing object, access its methods, and access its fields and properties. The following table maps the dynamic type checking in Java with its corresponding C# reflection features.
Exception HandlingC# and Java support formal exception handling and they have many similarities. They use very similar syntax for declaring exceptions; try blocks delineate guarded regions, catch blocks handle exceptions and finally blocks release any resources. Exceptions can be caught and re-thrown. You can either catch specific exceptions or use a catch-all statement. Unlike Java, C# does not have checked exceptions. In Java, checked exceptions are declared using the “throws” keyword and that must be handled by calling code. In C#, all exceptions are unchecked and there is no counterpart to the throws declaration for the method signature. try {
} //Most specific: catch (ArgumentNullException e) { Console.WriteLine(“{0}First exception caught.”, e); } //Least specific catch (Exception e) { Console.WriteLine(“{0}First exception caught.”, e); } Directory: uploads uploads -> 587 Return function, r i(X) r i(0) r i(1) r i(2) r i(3) 1 0 2 4 6 Thermal Station, I 2 0 1 5 6 3 0 3 5 6 10 uploads -> Department of science and humanities department of mathematics part-a questions and answers uploads -> The Case Against the nypd’s Quota-Driven ‘Broken Windows’ Policing What Is It? uploads -> For want of a nail uploads -> Ownership Models There are two different types of ownership models uploads -> Police Militarization uploads -> City of rising star regular meting thursday, july 14, 2016 uploads -> Township of winfield uploads -> Stop Militarizing Law Enforcement Act of 2014 uploads -> The Black Panther Party’s Ten-Point Program What We Want Now! Download 0.57 Mb. Share with your friends:
|