Upload
sagaroceanic11
View
287
Download
2
Tags:
Embed Size (px)
Citation preview
C# for Java Developers
@softwareartisan
A Broad Overview
.NET Platform JVM Platform
IL Intermediate
LanguageBytecode
C# F# VB.NET Java Groovy Scala
CLR(Common Language Runtime)
Win Win Mac UnixLinux
csc javacgroovyc
fscvbc
scalac
JRE(Java Runtime Environment)
Mono
Technology StackJava C#
Data Access
Client Side GUI
Web Side GUI
Web Scripting
Web Hosting
Remote Invocation
Messaging
Native
Directory Access
Componentization
JDBC ADO.NET
AWT/Swing WinForms, WPF
JSP, JavaFX, JSF ASP.NET, WebForms
Servlets, Filters ISAPI, HttpHandler, HttpModule
Tomcat, Jetty, Weblogic etc... IIS
RMI, Netty, AKKA Remoting, now part of WCF
JMS, AKKA MSMQ
JNI PInvoke
JNDI Active Directory (Ldap/ADSI)
EJB (Entity/Session), Spring COM+, Managed Extensibility Framework (MEF)
Language ComparisonJava C#
Program Entry Point
Namespace
Including Classes
Inheritance
Overriding
Accessing Parent Ctor
Accessing Parent Method
Visibility
main(String ...args) Main() or Main(string [] args)
package namespace
import using
class (extends),interface (implements) class and interface (:)
virtual by default non-virtual by defaultuse virtual keyword
super(...) : base(...)
super.method(...) base.Method(...)
private, package, protected, public
private, protected, internal, internal protected, public
Language ComparisonJava C#
Abstract Class
Non-Extensible Class
Non-Writable Field
Non-Extensible Method
Constant
Checking Instance Type
Enums
for-each construct
Switch-Case
abstract class X { ... } abstract class X { ... }
final class X { ... } sealed class X { ... }
final readonly
final sealed
static final const
instanceof is
enum, can have fields, methods and implement interfaces and are typesafe
enum, cannot have methods, fields or implement
interfaces, not typesafe
for (item : collection) { ... }
foreach(item in collection) { ... }
numeric types (int, float...) enums, and now
strings (in Java 7)
numeric types, enums and strings
Language ComparisonJava C#
Method Parameters
Variable Arguments
Exceptions
ADT Meta Type
Meta Information
Static class
Properties
Non-Deterministic Object Cleanup
Object References are passed by Value only
Object reference are passed by Value(default), ref & out
method(type... args) Method(params type[] args)
Checked and Unchecked(enforced by javac, not by JIT
compiler)All Unchecked Exceptions
ClassClass klass = X.class;
TypeType type = typeof(X);
@Annotation [Attribute]
Simulated by private Ctor and static methods
Static class and ctor with static methods
getProperty(), setProperty()
Property { get; set; }compiler generated get_Property() and
set_Property() methods
finalize() destructor ~X()
Language ComparisonJava C#
Deterministic Object Cleanup
Generics
Class Loading
synchronized block
synchronized method
Thread Local Storage
Smallest Deployment Unit
Signing
AutoCloseable or Closeable try-with-resources (Java 7)
try ( ... ) { ... }
IDisposableusing ( ... ) { ... }
<T>, <T extends Type>, <?>Type Erasure
<T>, where T : type, new()Preserves Type Info
Class.forName(“fqn”)ClassLoader.getResources()
Activator.CreateInstance<T>()Assembly.Load()
synchronized (this) { ... } lock (this) { ... }
synchronized method() { ... }
[MethodImpl(MethodImplOptions.Synchronized)]void Method() { ... }
Thread relative static fields Thread relative static fields [ThreadStatic] and Data Slots
Jar EXE/DLLPrivate Assembly, Shared Assembly
Jar Signing Assembly Signing
Specific to C#
• Aliases
• Verbatim Strings
• var
• Partial Class/Method
• Object Initializer
• Named Args
• Optional Args
• Value Types(struct)
• Nullable Types
• Safe Cast
• Tuples
• Extension Methods
• Operator Overloading
• Indexer
Value Typeor
Ref Type?
Value Type use ==
Reference Type use ReferenceEquals
Specific to C#: Equality
• For Value Types, default Equals implementation uses reflection on fields.
• Override Equals for Reference Types
• Use the same strategy for Value Types, it is more performant and consistent as well.
Equality Similarities
• Define Equals(object other) and hashCode as a part of the contract
• Define both in terms of immutable fields
• It should be
• Reflexive: x.Equals(x) => True
• Symmetric: if x.Equals(y) then y.Equals(x) => True
• Transitive: x.Equals(y) and y.Equals(z), then x.Equals(z) =>
True
Specific to C#: Equality
• Use Exact object argument - Equals for use in Collections and for performance.
• IEquatable<T>
• Preserve Value Semantics for Value Types
• Overload == operator
Implicit & Explicit Interfaces
01. interface Greet1 {02. public String greet();03. }04.05. interface Greet2 {06. public String greet();07. }08. 09. public class Greeter implements Greet1, Greet2 {10. //Implicit Implementation11. public String greet() {12. {13. return “Hello”;14. }15.16. public static void main(String ...args) {17. Greet1 greeter1 = new Greeter();18. greeter1.greet(); // Hello19. 20. Greet2 greeter2 = new Greeter();21. greeter2.greet(); // Hello22.23. Greeter greeter = new Greeter();24. greeter.greet(); // Hello25. }26. }
Implicit & Explicit Interfaces
01. interface Greet1 {02. public String greet();03. }04.05. interface Greet2 {06. public String greet();07. }08. 09. public class Greeter implements Greet1, Greet2 {10. //Implicit Implementation11. public String greet() {12. {13. return “Hello”;14. }15.16. public static void main(String ...args) {17. Greet1 greeter1 = new Greeter();18. greeter1.greet(); // Hello19. 20. Greet2 greeter2 = new Greeter();21. greeter2.greet(); // Hello22.23. Greeter greeter = new Greeter();24. greeter.greet(); // Hello25. }26. }
Java: Implicit means whether you use Greet1 or Greet2, it invokes the same implementation.
Implicit & Explicit Interfaces
01. interface Greet1 {02. public String greet();03. }04.05. interface Greet2 {06. public String greet();07. }08. 09. public class Greeter implements Greet1, Greet2 {10. //Implicit Implementation11. public String greet() {12. {13. return “Hello”;14. }15.16. public static void main(String ...args) {17. Greet1 greeter1 = new Greeter();18. greeter1.greet(); // Hello19. 20. Greet2 greeter2 = new Greeter();21. greeter2.greet(); // Hello22.23. Greeter greeter = new Greeter();24. greeter.greet(); // Hello25. }26. }
Java: Implicit means whether you use Greet1 or Greet2, it invokes the same implementation.
01. interface Greet102. {03. string Greet();04. }05. interface Greet206. {07. string Greet();08. }09. public class Greeter : Greet1, Greet210. {11. //Implicit Implementation12. public string Greet() //Note the Visibility here13. {14. return “Hello”;15. }16.17. public static void Main()18. {19. Greet1 greeter1 = new Greeter();20. greeter1.Greet(); // Hello21. Greet2 greeter2 = new Greeter();22. greeter2.Greet(); // Hello23. Greeter greeter = new Greeter();24. greeter.Greet(); // Hello25. }26. }
Implicit & Explicit Interfaces
01. interface Greet1 {02. public String greet();03. }04.05. interface Greet2 {06. public String greet();07. }08. 09. public class Greeter implements Greet1, Greet2 {10. //Implicit Implementation11. public String greet() {12. {13. return “Hello”;14. }15.16. public static void main(String ...args) {17. Greet1 greeter1 = new Greeter();18. greeter1.greet(); // Hello19. 20. Greet2 greeter2 = new Greeter();21. greeter2.greet(); // Hello22.23. Greeter greeter = new Greeter();24. greeter.greet(); // Hello25. }26. }
Java: Implicit means whether you use Greet1 or Greet2, it invokes the same implementation.
01. interface Greet102. {03. string Greet();04. }05. interface Greet206. {07. string Greet();08. }09. public class Greeter : Greet1, Greet210. {11. //Implicit Implementation12. public string Greet() //Note the Visibility here13. {14. return “Hello”;15. }16.17. public static void Main()18. {19. Greet1 greeter1 = new Greeter();20. greeter1.Greet(); // Hello21. Greet2 greeter2 = new Greeter();22. greeter2.Greet(); // Hello23. Greeter greeter = new Greeter();24. greeter.Greet(); // Hello25. }26. }
C#: Implicit interface implementation
Specific to C#: Explicit Interfaces
Specific to C#: Explicit Interfaces
01. interface Greet1 // v1.002. {03. string Greet();04. }05. interface Greet2 //v2.006. {07. string Greet();08. }09. public class Greeter : Greet1, Greet210. {11. //Explicit Implementations12. string Greet1.Greet() //Note the Visibility here13. {14. return “Hello from 1”;15. }16. string Greet2.Greet() //public not allowed for explicit17. {18. return “Hello from 2”;19. }20. public static void Main()21. {22. Greet1 greeter1 = new Greeter();23. greeter1.Greet(); // Hello from 124. Greet2 greeter2 = new Greeter();25. greeter2.Greet(); // Hello from 226. Greeter greeter = new Greeter();27. greeter. // No Greeters to Greet unless I cast28. }29. }
Specific to C#: Explicit Interfaces
01. interface Greet1 // v1.002. {03. string Greet();04. }05. interface Greet2 : Greet1 // v2.006. {07. new string Greet();08. }09. public class Greeter : Greet210. {11. //Explicit Implementations12. string Greet1.Greet() //Note the Visibility here 13. {14. return “Hello from 1”;15. }16. string Greet2.Greet() //public not allowed for explicit17. {18. return “Hello from 2”;19. }20. public static void Main()21. {22. Greet1 greeter1 = new Greeter();23. greeter1.Greet(); // Hello from 124. Greet2 greeter2 = new Greeter();25. greeter2.Greet(); // Hello from 226. Greeter greeter = new Greeter();27. greeter. // No Greeters to Greet unless I cast28. }29. }
01. interface Greet1 // v1.002. {03. string Greet();04. }05. interface Greet2 //v2.006. {07. string Greet();08. }09. public class Greeter : Greet1, Greet210. {11. //Explicit Implementations12. string Greet1.Greet() //Note the Visibility here13. {14. return “Hello from 1”;15. }16. string Greet2.Greet() //public not allowed for explicit17. {18. return “Hello from 2”;19. }20. public static void Main()21. {22. Greet1 greeter1 = new Greeter();23. greeter1.Greet(); // Hello from 124. Greet2 greeter2 = new Greeter();25. greeter2.Greet(); // Hello from 226. Greeter greeter = new Greeter();27. greeter. // No Greeters to Greet unless I cast28. }29. }
Specific to C#: Explicit Interfaces
01. interface Greet1 // v1.002. {03. string Greet();04. }05. interface Greet2 : Greet1 // v2.006. {07. new string Greet();08. }09. public class Greeter : Greet210. {11. //Explicit Implementations12. string Greet1.Greet() //Note the Visibility here 13. {14. return “Hello from 1”;15. }16. string Greet2.Greet() //public not allowed for explicit17. {18. return “Hello from 2”;19. }20. public static void Main()21. {22. Greet1 greeter1 = new Greeter();23. greeter1.Greet(); // Hello from 124. Greet2 greeter2 = new Greeter();25. greeter2.Greet(); // Hello from 226. Greeter greeter = new Greeter();27. greeter. // No Greeters to Greet unless I cast28. }29. }
01. interface Greet1 // v1.002. {03. string Greet();04. }05. interface Greet2 //v2.006. {07. string Greet();08. }09. public class Greeter : Greet1, Greet210. {11. //Explicit Implementations12. string Greet1.Greet() //Note the Visibility here13. {14. return “Hello from 1”;15. }16. string Greet2.Greet() //public not allowed for explicit17. {18. return “Hello from 2”;19. }20. public static void Main()21. {22. Greet1 greeter1 = new Greeter();23. greeter1.Greet(); // Hello from 124. Greet2 greeter2 = new Greeter();25. greeter2.Greet(); // Hello from 226. Greeter greeter = new Greeter();27. greeter. // No Greeters to Greet unless I cast28. }29. }
Explicitly State the interface for which the implementation is
Similarities• Immutable Strings
• Serialization
• Boxing
• Convert Value Type to a Reference Type
• Unboxing
• Convert Reference Type to a Value Type
Similarities
• Collections
• C# - IList, IDictionary, Queue, Stack
• Java - List, Map, Queue, Stack
• for-each Collection Iterators
Specific to C#• Collection Initializer
• Coroutines (more precisely Generators)
• yield break
• yield return
01. public static void Main() {02. foreach(int fiboSeq in new Fibonacci(5)) {03. Console.Out.WriteLine("{0}", fiboSeq);04. }05. }
Output:011235
Specific to C#• Collection Initializer
• Coroutines (more precisely Generators)
• yield break
• yield return
01. class Fibonacci : IEnumerable<int> {02. private readonly int howMany;03. private int firstSeed, secondSeed = 1;04.05. public Fibonacci(int howMany)06. {07. this.howMany = howMany;08. }09.10. public IEnumerator<int> GetEnumerator()11. {12. if (howMany < 0) 13. {14. yield break;15. }16. for (var i = 0; i <= howMany; i++)17. {18. yield return firstSeed;19. var sum = firstSeed + secondSeed;20. firstSeed = secondSeed;21. secondSeed = sum;22. }23. }24.25. IEnumerator IEnumerable.GetEnumerator()26. {27. return GetEnumerator();28. }29. }
01. public static void Main() {02. foreach(int fiboSeq in new Fibonacci(5)) {03. Console.Out.WriteLine("{0}", fiboSeq);04. }05. }
Output:011235
Covariance & Contravariance
• Covariance
• Pass collection of sub-class to a collection of base class
• Contravariance
• Pass collection of base class to a collection of sub-class
• Invariance
• Neither of the above applies
Arrays and Generic Collections
• Arrays are Covariant in C# and Java
• There is a hole in the type system and a runtime patch is applied.
• Generics are Invariant in Java.
• In C#, use leniency offered by IEnumerable if you need Covariance.
• Only interfaces and delegates can be covariant (out) or contravariant (in)
C# Example
C# Example01. abstract class Animal {02. public abstract string Speak();03. }04. 05. class Cat : Animal {06. public string Speak() {07. return “Meow!”;08. }09. }10. 11. class Dog : Animal {12. public string Speak() { 13. return “Bark!”;14. }15. }16.17. class Printer {18. public static Print(Animal [] animals) {19. animals[0] = new Dog();20. for (var i = 0; i < animals.Length; i++) {21. System.out.println(animals[i].speak();22. }23. } 24. 25. public static Print(IList<Animal> animals) {26. for (var animal in animals) {27. System.out.println(animal.Speak());28. }29. }30.
C# Example01. abstract class Animal {02. public abstract string Speak();03. }04. 05. class Cat : Animal {06. public string Speak() {07. return “Meow!”;08. }09. }10. 11. class Dog : Animal {12. public string Speak() { 13. return “Bark!”;14. }15. }16.17. class Printer {18. public static Print(Animal [] animals) {19. animals[0] = new Dog();20. for (var i = 0; i < animals.Length; i++) {21. System.out.println(animals[i].speak();22. }23. } 24. 25. public static Print(IList<Animal> animals) {26. for (var animal in animals) {27. System.out.println(animal.Speak());28. }29. }30.
01. public static Print(IEnumerable<Animal> animals)02. {03. for (var animal in animals) {04. Console.Out.WriteLine(animal.Speak());05. }06. }07. }08. class TestCollections {09. public static void main(String []args) {10. Cat cat = new Cat();11. Animal animal = cat;12. animal.speak();13. 14. animal = new Dog();15. animal.speak();16.17. Animal [] animals = new Animal [] { cat, dog }; 18. Cat [] cats = new Cat[] { cat };19. animals = cats;20. Print(animals); //Exposes Hole in Type System 21. 22. // In absence of above Print method, the code23. // does not compile as Generic Collections in24. // C# are Invariant. 25. List<Animal> animals = new ArrayList<Dog>();2627. //We need Co-variance to allow this to compile28. Printer.Print(dogs); 29. 30. }31. }
Java Example
Java Example01. abstract class Animal {02. public abstract String speak();03. }04. 05. class Cat extends Animal {06. public String speak() {07. return “Meow!”;08. }09. }10. 11. class Dog extends Animal {12. public String speak() { 13. return “Bark!”;14. }15. }16.17. class Printer {18. public static print(Animal [] animals) {19. animals[0] = new Dog();20. for (int i = 0; i < animals.length; i++) {21. System.out.println(animals[i].speak();22. }23. } 24. 25. public static print(List<Animal> animals) {26. for(Animal animal : animals) {27. System.out.println(animal.speak());28. }29. }30. }
Java Example01. class TestCollections {02. public static void main(String []args) {03. Cat cat = new Cat();04. Animal animal = cat;05. animal.speak();06. 07. animal = new Dog();08. animal.speak();09.10. Animal [] animals = new Animal [] { cat, dog }; 11. Cat [] cats = new Cat[] { cat };12. animals = cats;13. print(animals); //Exposes Hole in Type System 14. 15. // Fails to compile as Generic Collections in16. // Java are Invariant17. List<Animal> animals = new ArrayList<Dog>();18. 19. List<Dog> dogs = new ArrayList<Dog>();20. dogs.add(dog);21. dogs.add(dog);22. print(dogs);23. }24. }
01. abstract class Animal {02. public abstract String speak();03. }04. 05. class Cat extends Animal {06. public String speak() {07. return “Meow!”;08. }09. }10. 11. class Dog extends Animal {12. public String speak() { 13. return “Bark!”;14. }15. }16.17. class Printer {18. public static print(Animal [] animals) {19. animals[0] = new Dog();20. for (int i = 0; i < animals.length; i++) {21. System.out.println(animals[i].speak();22. }23. } 24. 25. public static print(List<Animal> animals) {26. for(Animal animal : animals) {27. System.out.println(animal.speak());28. }29. }30. }
Specific to C#• Anonymous Types
• Anonymous Methods/Delegates
• Pass Methods as Data
• Action: No return values
• Func: Non-void return values
• Predicate: A Func that always returns a bool
• Generally above suffice, but if not,then use Custom Delegates
• Delegate Chaining
• Compiler Eye Candy: +=, -= for Combine(), Remove()
• Lambdas
Specific to C#• Events
• Syntactic sugar over delegates, but with visibility
• Events can only be invoked from within the class that declared it, whereas a delegate field can be invoked by whoever has access to it.
• Events can be included in interfaces, delegates cannot be.
• Built-in EventHandler and EventArgs
• Compiler generated add_ and remove_ methods for the event.
• dynamic
• ExpandoObject
Dynamic Runtime Library
CLR(Common Language Runtime)
DLR(Dynamic Language Runtime)
C#
VB.NET
PythonRuby
• Allows you to talk with implementations in other languages
• C#/VB.NET with Python, Ruby
• Also with Silverlight etc..
Dynamically Typed
Statically Typed
01. using IronPython.Hosting;02. using Microsoft.Scripting.Hosting;03.04. var python = Python.CreateRuntime();05. dynamic script = python.UseFile(“Calculator.py”);06.07. // Get PythonType08. dynamic Calculator = script.GetVariable(“Calculator”);09. dynamic calc = Calculator(); // Instantiate Object10. 11. //Invoke method12. dynamic result = calc.add(2, 3); // 5
Specific to C#
• Avoid Configuration hell
• Single Configuration File (App.config)
• Asynchronous Programming
• BeginInvoke and EndInvoke• Wait with EndInvoke
• Wait with WaitHandle
• Poll for Async call completion
• Execute a callback upon completion
• Task Parallel Library (TPL)
Specific to Java
• Static Imports
• Instance and Static Initializers
• Interfaces Containing Fields
• Anonymous Classes
• Proxy Support through Interceptor
Specific to Java
• Asynchronous Programming
• Future Task
• Poll Completion with isDone().
• Execute callback upon completion
• Using ListenableFuture and FutureCallback - Google Guava Library
• Or roll your own result completion callback.
• Akka Actors
Frameworks and ToolsJava C#
Dependency Injection Frameworks
ORM Frameworks
Proxying/AOP Frameworks
TDD Frameworks
Mocking Frameworks
BDD Frameworks
Build Tools
Coverage Tools
Profiler
Code Analysis Tools
Spring, Guice, Pico Container etc... Spring.NET, Unity Container
Hibernate, iBatis etc... NHibernate, Entity Framework
JDK Proxy, Spring AOP, CGLib AspectJ, AspectWerkz
Castle Proxy, Rhino Proxy, Unity Interceptor
JUnit, TestNG NUnit, MSTest
JMock2, Mockito, EasyMock Rhino Mocks, Moq, TypeMock
Cucumber, JBehave, Spock, Easyb NBehave, SpecFlow, NSpec
Ant, Maven, Gradle, Ivy NAnt, MSBuild, NMaven
Cobertura, Emma, Clover NCover, OpenCover
JProfiler, YourKit dotTrace, YourKit.NET
FindBugs, PMD, Checkstyle, JDepend
FxCop, NDepend, ReSharper, Simian
References
• MSDN Site
• Venkat Subramaniam
• http://agiledeveloper.com/presentations/CSharpForJavaProgrammers.zip
• Wikipedia
• http://en.wikipedia.org/wiki/Comparison_of_C_Sharp_and_Java
• Dare Obasanjo
• http://www.25hoursaday.com/CsharpVsJava.html
• Scott Hanselman
• http://www.hanselman.com/blog/
C4AndTheDynamicKeywordWhirlwindTourAroundNET4AndVisualStudio2010Beta1.aspx