Est-ce que le modificateur d'accès `internal` peut être utilisé pour diviser une classe sur plusieurs fichiers?

Question

Le sujet dans lequel je suis actuellement est le partage de code. Il est suggéré d'utiliser le modificateur d'accès internal pour partager le code entre plusieurs fichiers. Mais est-ce? Ou est-ce que je me trompe? Je ne peux pas poster le lien, car la source n'est pas accessible à tout le monde.

Est-il possible d'avoir la définition d'une classe dans un fichier (comme une interface, ou une classe abstraite) et de l'implémenter dans un autre fichier (et d'utiliser ici internal)?

Voici un pseudo code (qui ne fonctionne évidemment pas). Définition dans un seul fichier:

internal static class SongLoader 
{ 
    internal async static Task<IEnumerable<Song>> Load(); 
    internal async static Task<Stream> OpenData(); 
} 

mise en œuvre dans un autre fichier:

internal static class SongLoader 
{ 
    internal const string Filename = "songs.json"; 

    internal static async Task<IEnumerable<Song>> Load() 
    { 
     // implementation 
    } 

    internal static Stream OpenData() 
    { 
     // implemenation 
    } 
} 

Ou est-il possible d'avoir Load() définis dans un fichier et OpenData() dans un autre, tout en utilisant internal modificateur d'accès? Est-ce possible? Comment?

Answer 1

internal spécificateur est utilisé pour limiter les classes/membres étant utilisé autrement que dans l'ensemble contenant.

Le partage de code est réalisé via les classes partial. Vous pouvez avoir une partie d'une classe dans un fichier et l'autre partie dans un autre fichier.

Dans un fichier

public partial class MyClass 
{ 
    public void Foo() 
    { 
    } 
} 

Dans le fichier B

public partial class MyClass 
{ 
    public void Bar() 
    { 
    } 
} 

Vous ne pouvez pas avoir la déclaration dans un seul fichier et la définition dans un fichier comme dans C++. Si vous avez de telles exigences, vous devriez penser aux classes interface ou abstract.

Answer 2

internal est un modificateur d'accès qui traite du code pouvant accéder à vos fonctions. Ce que vous cherchez est le mot-clé partial si vous voulez diviser une classe en plusieurs fichiers dans le même espace de noms.

https://msdn.microsoft.com/en-us/library/wa80x488.aspx

partial vous ne laissera pas définir la même définition de fonction deux fois; vous devrez remplacer ou virtualiser, ou travailler avec une classe de base si c'est ce que vous visez. Partiel est pratique à certains moments, mais il peut conduire à une solution quelque peu encombrée si vous n'êtes pas sûr de quelle classe peut être trouvé où.

Answer 3

Les modificateurs d'accès ne traitent que de qui peut voir le code, pas comment il est implémenté.
Le moyen le plus proche de faire ce que vous voulez est d'utiliser abstract classes.

A titre d'exemple:

internal abstract class SongLoader //under SongLoader.cs 
{ 
    internal async virtual Task<IEnumerable<Song>> Load(); 
    internal async virtual Task<Stream> OpenData(); 
} 

internal sealed class SongLoaderImplementer : SongLoader //under SongLoaderImplementer.cs 
{ 
    internal override async Task<IEnumerable<Song> Load() {} 
    internal override async Task<Stream> OpenData() {} 
}