What is the difference between metadata annotations in C# and Java?

What is the difference between metadata annotations in C# and Java?

Metadata annotations are a method of extending programming language capabilities. Annotations can take the form of directives requesting that the runtime

  • extend type cabilities;
  • perform specific tasks;
  • provide information about an item.

C# attributes

C# attributes allow a developer to add annotations—that is, metadata—to a member variable, method, module, parameter, or type. The following are brief descriptions of a few intrinsic .NET attributes which can be employed to extend C# capabilities:

  • [FlagsAttribute] specifies that an enum supports bitwise operations. This is useful for enumerations with multiple value targets.
  • [MethodImpl(MethodImplOptions.Synchronized)] specifes that multiple thread access to a method is controlled by a lock designed to prevent concurrent access problems. This is analogous to the synchronized Java keyword.
  • [Serializable] marks a class as serializable. It is the C# analogue of a Java class which implements the Serializable interface.
  • [WebMethod] specifies—along with ASP.NET—that a method will be—automatically—made available as a Web service. The Java equivalent involves a complex configuration of Java Enterprise Edition, JAXP, and UDDI plus creating an Enterprise JavaBean—a bean class implementing two interfaces and a deployment descriptor.

Java annotations

Java annotations provide a way to add annotations—that is, metadata—to a local variable, member, method, package, parameter, or type. The Java system supports three built-in annotations as follows:

  • @Deprecated flags a method as deprecated—obsolescent—and causes a compiler warning to be generated.
  • @Override specifies that a method will override a base class method. If the annotated method does not do so, then a compiler error will result.
  • @SuppressWarnings is used to suppress specific compiler warnings. This annotation can accept the name of the specific warning message to be suppressed.

Custom annotations and attributes

In C#, custom attributes can be created by developers by subclassing the System.Attribute.

In the Java system, custom annotations can be created by developers using the @interface annotation.


In C#, the attributes of a class, field, method, or module can be accessed using reflection. Use this feature to obtain class metadata or to determine at runtime whether a class supports certain behaviors.

In the Java system, class, field, method, or module annotations can be accessed via reflection. But, C# attributes and Java annotations differ in that only in the Java system can annotations be put on annotations.

See also

About eagle081183

Passionate, Loyal
This entry was posted in C#, Java, Programming. Bookmark the permalink.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s