Do not use AutoDual ClassInterfaceType

TypeName	DoNotUseAutoDualClassInterfaceType
CheckId	CA1408
Category	Microsoft.Interoperability
Breaking Change	Breaking

Cause

A COM visible type is marked with the System.Runtime.InteropServices.ClassInterfaceAttribute attribute set to System.Runtime.InteropServices.ClassInterfaceType.AutoDual.

Rule Description

Types that use a dual interface allow clients to bind to a specific interface layout. Any changes in a future version to the layout of the type or any base types will break COM clients that bind to the interface. By default, if the ClassInterfaceAttribute attribute is not specified, a dispatch-only interface is used.

Unless marked otherwise, all public non-generic types are visible to COM; all non-public and generic types are invisible to COM.

How to Fix Violations

To fix a violation of this rule change the value of the ClassInterfaceAttribute attribute to None and explicitly define the interface.

When to Exclude Warnings

Do not exclude a warning from this rule unless it is certain that the layout of the type and its base types will not change in a future version.

Example

The following example shows a class that violates the rule and a re-declaration of the class to use an explicit interface.

Imports System
Imports System.Runtime.InteropServices

<Assembly: ComVisibleAttribute(True)>
Namespace InteroperabilityLibrary

   ' This violates the rule.
   <ClassInterfaceAttribute(ClassInterfaceType.AutoDual)> _ 
   Public Class DualInterface
      Public Sub SomeSub
      End Sub
   End Class

   Public Interface IExplicitInterface
      Sub SomeSub
   End Interface

   <ClassInterfaceAttribute(ClassInterfaceType.None)> _ 
   Public Class ExplicitInterface
      Implements IExplicitInterface

      Public Sub SomeSub Implements IExplicitInterface.SomeSub
      End Sub

   End Class

End Namespace

using System;
using System.Runtime.InteropServices;

[assembly: ComVisible(true)]
namespace InteroperabilityLibrary
{
   // This violates the rule.
   [ClassInterface(ClassInterfaceType.AutoDual)]
   public class DualInterface
   {
      public void SomeMethod() {}
   }

   public interface IExplicitInterface
   {
      void SomeMethod();
   }

   [ClassInterface(ClassInterfaceType.None)]
   public class ExplicitInterface : IExplicitInterface
   {
      public void SomeMethod() {}
   }
}

Related Rules

Auto layout types should not be ComVisible

Mark ComSource interfaces as IDispatch

See Also

Concepts

Introducing the Class Interface
Qualifying .NET Types for Interoperation

Other Resources

Interoperating with Unmanaged Code