Contents - Cultural View

e="6.73">
= 42;
= null;
Comparison of Java and C Sharp 67
int? a = 42;
int? b = null;
ill generate a runtime NullPointerException
// c will receive the null value
e the * operator will attempt to unbox the null value // because * is lifted and one of the operands
= a * b;
int? c = a * b;
Not all C# lifted operators have been defined to propagate null unconditionally if one of the operands is null.
Specifically, the boolean operators have been lifted to support ternary logic thus keeping impedance with SQL.
Late-bound (dynamic) type
C# features a late bound dynamic type which supports no-reflection dynamic invocation, interoperability with
dynamic languages as well as ad-hoc binding to (for example) document object models. The dynamic type resolves
member access dynamically at runtime as opposed to statically/virtual a compile time. The member lookup
mechanism is extensible with traditional reflection as a fall-back mechanism.
There are several use cases for the dynamic type in C#:
• Less verbose use of reflection: By casting an instance to the dynamic type, members such as properties, methods,
events etc. can be directly invoked on the instance without using the reflection API directly.
• Interoperability with dynamic languages: The dynamic type comes with a hub-and-spoke support for
implementing dynamically typed objects and common runtime infrastructure for efficient member lookup.
• Creating dynamic abstractions on the fly: For instance, a dynamic object could provide simpler access to
document object models such as XML- or XHTML documents.
Java does not support a late-bound type. The use cases for C# dynamic type have different corresponding constructs
in Java:
• For dynamic late-bound by-name invocation of preexisting types, reflection should be used.
• For interoperability with dynamic languages, some form of interoperability API specific to that language will
have to be used. The Java Virtual Machine platform does have multiple dynamic languages implemented on top if
it, but there is no common standard for how to pass objects between languages. Usually this will involve some
form of reflection or reflection-like API. As an example of how to use JavaFX objects from Java, see How to Use
JavaFX in Your Swing Application [1] .
• For creating and interacting with objects entirely at runtime, e.g. interaction with a document object model
abstraction, a specific abstraction API will have to be used.
Pointers
C# allows use of pointers and corresponding pointer arithmetic. Pointers and pointer-arithmetic are potentially
unsafe in a managed environment as they can be used to bypass the strict rules for object access. C# addresses that
concern by requiring that code blocks or methods that use the feature be marked with the unsafe keyword, so that all
clients of such code can be aware that the code may be less secure than otherwise. The compiler requires the /unsafe
switch to allow compilation of a program that uses such code, and assemblies containing unsafe code may only
execute if explicitly granted security permissions. Generally, unsafe code is either used to allow better
interoperability with unmanaged APIs or system calls (which are inherently "unsafe"), or for performance reasons.
Java does not permit pointers or pointer-arithmetic within the Java runtime environment and native interop is
handled externally through JNI or other mechanisms.