Add option for including explicit interface implementations

Author: mikernet

src/Microsoft.DocAsCode.Dotnet/DotnetApiCatalog.cs

@@ -110,6 +110,7 @@ private static ExtractMetadataConfig ConvertConfig(MetadataJsonItemConfig config
                 ShouldSkipMarkup = configModel?.ShouldSkipMarkup ?? false,
                 FilterConfigFile = configModel?.FilterConfigFile is null ? null : Path.GetFullPath(Path.Combine(EnvironmentContext.BaseDirectory, configModel.FilterConfigFile)),
                 IncludePrivateMembers = configModel?.IncludePrivateMembers ?? false,
+                IncludeExplicitInterfaceImplementations = configModel?.IncludeExplicitInterfaceImplementations ?? false,
                 GlobalNamespaceId = configModel?.GlobalNamespaceId,
                 UseCompatibilityFileName = configModel?.UseCompatibilityFileName ?? false,
                 MSBuildProperties = configModel?.MSBuildProperties,

src/Microsoft.DocAsCode.Dotnet/ExtractMetadata/ExtractMetadataConfig.cs

@@ -21,6 +21,8 @@ internal class ExtractMetadataConfig
 
         public bool IncludePrivateMembers { get; init; }
 
+        public bool IncludeExplicitInterfaceImplementations { get; init; }
+
         public bool UseCompatibilityFileName { get; init; }
 
         public string GlobalNamespaceId { get; init; }

src/Microsoft.DocAsCode.Dotnet/MetadataJsonItemConfig.cs

@@ -30,6 +30,9 @@ internal class MetadataJsonItemConfig
         [JsonProperty("includePrivateMembers")]
         public bool IncludePrivateMembers { get; set; }
 
+        [JsonProperty("includeExplicitInterfaceImplementations")]
+        public bool IncludeExplicitInterfaceImplementations { get; set; }
+
         [JsonProperty("globalNamespaceId")]
         public string GlobalNamespaceId { get; set; }
 

src/Microsoft.DocAsCode.Dotnet/SymbolFilter.cs

@@ -94,8 +94,25 @@ private bool IsSymbolAccessible(ISymbol symbol)
             if (symbol.IsImplicitlyDeclared && symbol.Kind is not SymbolKind.Namespace)
                 return false;
 
+            if (_config.IncludeExplicitInterfaceImplementations)
+            {
+                bool isEii = symbol.Kind switch
+                {
+                    SymbolKind.Method => IsEiiAndIncludesContainingSymbols(((IMethodSymbol)symbol).ExplicitInterfaceImplementations),
+                    SymbolKind.Property => IsEiiAndIncludesContainingSymbols(((IPropertySymbol)symbol).ExplicitInterfaceImplementations),
+                    SymbolKind.Event => IsEiiAndIncludesContainingSymbols(((IEventSymbol)symbol).ExplicitInterfaceImplementations),
+                    _ => false,
+                };
+
+                if (isEii)
+                    return true;
+            }
+
             if (_config.IncludePrivateMembers)
             {
+                if (_config.IncludeExplicitInterfaceImplementations)
+                    return true;
+
                 return symbol.Kind switch
                 {
                     SymbolKind.Method => IncludesContainingSymbols(((IMethodSymbol)symbol).ExplicitInterfaceImplementations),
@@ -114,6 +131,11 @@ bool IncludesContainingSymbols(IEnumerable<ISymbol> symbols)
             {
                 return !symbols.Any() || symbols.All(s => IncludeApi(s.ContainingSymbol));
             }
+
+            bool IsEiiAndIncludesContainingSymbols(IEnumerable<ISymbol> symbols)
+            {
+                return symbols.Any() && symbols.All(s => IncludeApi(s.ContainingSymbol));
+            }
         }
     }
 }