The Moth

This is the title of a blog post that immediately got my attention. I had to dig further, so here is the process.

Look at the attribute with a decompiler:

[AttributeUsage(AttributeTargets.Delegate | (AttributeTargets.Parameter | 

(AttributeTargets.Interface | (AttributeTargets.Event | 

(AttributeTargets.Field | (AttributeTargets.Property | 

(AttributeTargets.Method | (AttributeTargets.Enum | 

(AttributeTargets.Struct | (AttributeTargets.Class | 

AttributeTargets.Assembly))))))))), 

AllowMultiple=true,  Inherited=false), ComVisible(true)]

public sealed class ObfuscationAttribute : Attribute {

      // Constructor

      public ObfuscationAttribute();



      // Properties

      public bool ApplyToMembers;

      public bool Excludet

      public string Feature;

      public bool StripAfterObfuscation;



      // Fields

      private bool mApplyToMembers;

      private bool mExclude;

      private string mFeature;

      private bool mStripAfterObfuscation;

}

If you think drilling deeper will tell you anything, don't hold your breath; the properties are plain accessors for the fields and this is the ctor:

public ObfuscationAttribute(){

      mStrip = true;

      mExclude = true;

      mApplyToMembers = true;

      mFeature = "all";

}

OK, so the class itself doesn't unveil the mystery, but maybe applying it to one of our methods and then examining that will:

[System.Reflection.Obfuscation()]

public int ObfuscateThisPlease() {

	int j = 6;

	int i = 5 + j;

	return (j - i);

}



.method public hidebysig instance int32  ObfuscateThisPlease() cil managed

{

  .custom instance void [mscorlib]ObfuscationAttribute::.ctor()=(01 00 00 00)

  // Code size       10 (0xa)

  .maxstack  2

  .locals init ([0] int32 j,

           [1] int32 i)

  IL_0000:  ldc.i4.6

  IL_0001:  stloc.0

  IL_0002:  ldc.i4.5

  IL_0003:  ldloc.0

  IL_0004:  add

  IL_0005:  stloc.1

  IL_0006:  ldloc.0

  IL_0007:  ldloc.1

  IL_0008:  sub

  IL_0009:  ret

} // end of method Program::ObfuscateThisPlease

Nada. Tzifos. Nothing. At this point there is only one thing left to do: RTFM, and all is revealed:

"Instructs obfuscation tools to take the specified actions for an assembly, type, or member."

Well I bet, like me, you guys (and gals) were hoping System.Reflection.ObfuscationAttribute would be a pseudo-custom attribute rather than just a marker for 3rd party tools, but not every journey leads to a treasure :-(

I guess I could be applying it to all my privates automatically since, as we know, custom attributes cost absolutely nothing, until you explicitly reflect on them.

(Just to get this out of my system: I think the term Attribute is an unfortunate choice by the .NET designers. "Annotation", "decoration", "declaration", “metadata” or anything else would have not only conveyed the purpose better, but would also not clash with the UML's existing use of the keyword "attribute" to mean fields/data_members of a class)