What are the similarities and differences between Java Annotations and C# Attributes?

Question

I have a Java library I'm considering porting to C#. The Java library makes extensive use of annotations (at both build time and run time.)

I've never used C# attributes, but understand that they are the rough equivalent of Java annotations.

If I proceed with the port using attributes to replace annotations, what do I need to know? What's going to be the same? Different? What's going to bite me?

EDIT: I'd really like a nice list of design considerations to think about when "porting" some Java annotations to C# attributes - and I haven't gotten that yet. I'll stick a bounty on here, and see if that makes it worth someone's effort.

Answer 1

One important aspect of Java annotations which I haven't looked at in detail yet: you can write code which uses annotations within javac (as of Java 6, I believe) as a form of metaprogramming.

PostSharp allows something similar, admittedly.

(That's far from the only difference, but it's all I have time for right now.)

Answer 2

Following up to what Jon said...

Both Java 5 and Java 6 allow metaprogramming. Java 5 uses a separate apt tool; Java 6 integrates it into the compiler. (Though the Java 5 apt is still available in Java 6)

Unfortunately each uses a different API.

I'm currently using the Java 5 API for my Bean annotations

See http://code.google.com/p/javadude/wiki/Annotations for an example (NOTE: I'm currently making some major updates, some of which change the API.)

Very cool stuff... -- Scott

Answer 3

One interesting difference is that C# allows module and assembly level attributes. These are applied to your module or assembly and are available via reflection in the normal way. Java does not provide reflection on a jar file, so jar level annotations are not possible.

In fact this is quite common as Visual Studio a file called AssemblyInfo.cs at the root project level which contains, for example:

[assembly: AssemblyVersionAttribute("1.2.3.4")]
[assembly: AssemblyTitleAttribute("My project name blah blah")]
...

There is no equivalent jar level annotation in Java (although since jdk5, there is a little used package level annotation mechanism - thanks to mmeyers for pointing that one out)

Answer 4

Control over when your metadata is made accessible is different between the two languages.

Java provides the java.lang.annotation.Retention annotation and java.lang.annotation.RetentionPolicy enum to control when annotation metadata is accessible. The choices vary from Runtime (most common - annotation metadata retained in class files), to Source (metadata discarded by compiler). You tag your custom annotation interface with this - for example:

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.CLASS)
public @interface TraceLogging {
  // etc
}

would allow you to reflect on your custom TraceLogging annotation at runtime.

C# uses the ConditionalAttribute attribute that is driven from compile time symbols. So the analogous example in C# is:

[Conditional("TRACE")]
public class TraceLoggingAttribute : Attribute
{
  // etc
}

which would cause the compiler to spit out the metadata for your custom TraceLogging attribute only if the TRACE symbol was defined.

NB. attribute metadata is available at runtime by default in C# - this is only needed if you want to change that.