C # Partager le code entre les cours

Une classe d'utilitaire C # fonctionnera. Il agit comme un registre central pour le code commun (ou comme la construction du module VB.net) - il devrait contenir du code qui n'est pas spécifique à une classe sinon il aurait dû être joint à la classe concernée.

vous ne voulez pas strong> vouloir commencer à copier le code source, si vous n'êtes pas obligé, car cela conduirait à des problèmes de mise à jour du code en tenant compte de la double duplication forte>. p>

Tant que la source n'a pas besoin de conserver l'état, utilisez une classe statique avec une méthode statique. P>

static public class MySharedMembers {
    static public string ConvertToInvariantCase(string str)  {
        //...logic
    }
    // .... other members
}

Pour être honnête, je ne peux penser à rien de ce genre d'informations inclus dans Visual C #, ni pourquoi vous voudriez que cette fonctionnalité. Cela dit, des classes partielles peuvent faire quelque chose comme ça sonne ce que vous voulez, mais les utiliser peut-être des affrontements contre vos "classes ayant déjà une hiérarchie significative" exigence.

Si les classes sont dans la même espace de noms, il n'est pas nécessaire d'inclure un analogique. Appelez simplement les membres de la classe définis dans l'autre fonction.

S'ils ne sont pas dans la même espace de noms, ajoutez l'espace de noms des classes que vous souhaitez utiliser dans les directives de jugement et doit fonctionner comme ci-dessus.

Je suis confus par la question: il semble que vous ayez besoin de travailler sur votre bonne compréhension de OO.

Commander des méthodes d'extension: http://msdn.microsoft.com/fr -us / bibliothèque / bb383977.aspx

Je ne suis pas sûr de ce que vous entendez déjà par une structure "significative" déjà, mais cela ressemble à un endroit où vous pourriez utiliser la mise en œuvre de la classe de base. Bien que non aussi «verbose» que le héritage multiple C ++, vous pourriez obtenir des avantages à l'aide de la mise en œuvre de la classe de base chaînée pour réutiliser les fonctions communes.

Vous pouvez préserver la hiérarchie de la classe, au moins visuellement et remplacer le comportement au besoin.

Vous ne pouvez pas simplement charger du code que vous souhaitez ajouter dans une classe en C # via une directive de pré-déprocession que vous le feriez dans C.

Vous pouvez définir une interface et déclarer des méthodes d'extension pour cette interface. L'interface pourrait ensuite être mise en œuvre par vos classes et vous pouvez appeler les méthodes d'extension sur ces classes. EG P>

public interface IShareFunctionality { }

public static class Extensions
{
    public static bool DoSomething(this IShareFunctionality input)
    {
        return input == null;
    }
}

public class MyClass : Object, IShareFunctionality
{
    public void SomeMethod()
    {
        if(this.DoSomething())
            throw new Exception("Impossible!");
    }
}

Vous avez de nombreuses options, TT, Extension, Déléguat et Lambda

Je ne connais pas un moyen d'inclure des portions de fichiers, mais une chose que nous faisons fréquemment consiste à ajouter un fichier existant et "lien" de son emplacement actuel. Par exemple, nous avons un fichier associéInfo.cs que chaque projet fait référence à partir d'un répertoire de solution. Nous le changeons une fois et tous les projets ont les mêmes informations car ils se réfèrent au même fichier.

Sinon, des suggestions sur le refactoring des routines "communes" dans un commun.dll sont la meilleure chose que j'ai proposée dans .net.

Si vous avez des fonctionnalités que vous utilisez fréquemment dans des classes qui représentent des choses très différentes, dans mon expérience qui devrait tomber dans quelques catégories:

• Utilitaires (E.G. Formatage des chaînes, analyse, ...) li>
• Préoccupations transversales (journalisation, application de la sécurité, ...) li> ul>

  Pour les fonctionnalités de type utilitaire, vous devez envisager de créer des classes séparées et référencer les classes utilitaires si nécessaire dans la classe d'entreprise. P>

  // Simplified example to explain:
  
  public interface IPrint 
  { 
     public void Print(string); 
  }
  
  public class PrintA : IPrint
  {
     public void Print(string input)
     { ... format as desired for A ... }
  }
  
  public class PrintB : IPrint
  {
     public void Print(string input)
     { ... format as desired for B ... }
  }
  
  class MyPage
  {
     IPrint printer;
  
     public class MyPage(bool usePrintA)
     {
        if (usePrintA) printer = new PrintA(); else printer = new PrintB();
     }
  
     public PrintThePage()
     {
        printer.Print(thePageText);
     }
  }
  

Sortez le code répétitif dans les services. Le code répétitif est un indice qu'il pourrait y avoir une place pour le refactoring.

Par exemple, créez un "PrintOnService" qui contient la logique nécessaire pour imprimer. Vous pouvez ensuite avoir les classes qui doivent imprimer avoir une dépendance à ce service (via le constructeur ou un paramètre dans une méthode qui nécessite le service).

Un autre conseil que j'ai le long de ces lignes est de créer des interfaces pour la fonctionnalité de base, puis d'utiliser les interfaces pour le code. Par exemple, j'ai eu des saisies de classes de rapport que l'utilisateur pourrait soit fax, email ou imprimer. Au lieu de créer des méthodes pour chacun, j'ai créé un service pour chacun, les avions implémenter une interface comportant une seule méthode de sortie (). Je pourrais ensuite passer chaque service à la même méthode en fonction du type de sortie souhaité par l'utilisateur. Lorsque le client souhaitait utiliser EFAX au lieu de faxer par le modem, il s'agissait simplement d'écrire un nouveau service mis en œuvre cette même interface.