Non CLS-Compliant Code in C#

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:

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()
{
}

Declaring a member name preceding underscore (_) with outside visible access specifiers (public, protected, protected internal):
```
public void _test()
{
:::::::
}
```
Declaring unsigned type member with access public / protected / protected internal:
```
public uint a = 10;
```
Declaring unsafe (pointer) type with access public / protected / protected internal:
```
protected internal unsafe int *c;
```
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)
{
::::::::
}
```

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;
}