Introduction

Common Language Specification (CLS) is a set of basic rules and it is expected that a .NET language must satisfy them. Though C# is probably the biggest language in .NET Framework, it supports many non-CLS-compliant codes mainly to support and maintain the legacy language nativity. Writing C# programs by using only CLS-compliant code gives great portability among other .NET programs written in other .NET languages. This article tries to list non CLS-compliant codes in C#.

Using the Code

Given below are some samples for non-CLS compliant code:

1. Two or more public / protected / protected internal members defined with only case difference:

   public int intA = 0;
   public int INTA = 2;

   public int x = 0;
   
   public void X()
   {
   }

2. Declaring a member name preceding underscore (_) with outside visible access specifiers (public, protected, protected internal):

   public void _test()
   {
   :::::::
   }

3. Declaring unsigned type member with access public / protected / protected internal:

   public uint a = 10;
   

4. Declaring unsafe (pointer) type with access public / protected / protected internal:

   protected internal unsafe int *c;

5. A (public / protected / protected internal) method returning a non-CLS compliant type or with parameter of non-CLS compliant type:

   public uint testmethod(int x, int y)
   {
   ::::::::
   }

   public void anothermethod(ushort x, int y)
   {
   ::::::::
   }

6. An abstract member marked as non-CLS-Compliant in a CLS-Compliant class:

   [CLSCompliant(true)]
   public abstract class B
   {
   [CLSCompliant(false)]
   protected internal abstract void test();
   }

All the code listed above is not CLS-compliant and one should avoid this type of coding to ensure CLS-Compliant code. Many of the CLS are followed by C# and the above list mentioned some of them are not pursued by C#.

There is an attribute, called CLSCompliant, to check whether our code written is CLS-compliant or not. By giving CLSCompliant attribute with true parameter, we can get a warning message for all non CLS-Compliant code.

using System;
[assembly: CLSCompliant(true)]
public class Test
{
public static int a = 10;

public int intA = 0;
public int INTA = 2;

public int x = 0;
public void X()
{
}
protected uint testmethod(int x, int y)
{
return 0;
}
}

[assembly: CLSCompliant(true)] means the CLS-Compliant is enabled to the assembly. After setting this, the compiler will check all code in the assembly for CLS-Compliant and if we want any class or method to not check for CLS-Compliant, we can give false for that member alone.

using System;
[assembly: CLSCompliant(true)]
[CLSCompliant(false)]
public class clsA
{
public unsafe int* x;
}

public class clsB
{
public unsafe int* x;
}

[CLSCompliant(true)]
public class clsC
{
public unsafe int* x;
}

The clsA class will not be checked by the compiler for CLS-Compliant, but the compiler will do for clsB and clsC.