C# споделя код между класовете

Ако имате функционалност, която използвате често в класове, които представляват много различни неща, според моя опит това трябва да попада само в няколко категории:

• Помощни програми (напр. форматиране на низове, анализиране, ...)
• Междусекторни опасения (регистриране, прилагане на сигурността, ...)

За функционалност от тип полезност трябва да помислите за създаване на отделни класове и препращане към класовете помощни програми, където е необходимо в бизнес класа.

public class Validator
{
  public bool IsValidName(string name);
}

class Patient
{
  private Validator validator = new Validator();
  public string FirstName
  {
     set
     {
         if (validator.IsValidName(value)) ... else ...
     }
  }
}

За междусекторни проблеми, като регистриране или сигурност, ви предлагам да проучите Аспектно-ориентирано програмиране .

Що се отнася до примера PrintA срещу PrintB, обсъден в други коментари, звучи като отличен случай за фабричния шаблон. Вие дефинирате интерфейс, напр. IPrint, класове PrintA и PrintB, които изпълняват IPrint и присвояват екземпляр на IPrint въз основа на нуждите на конкретната страница.

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

Не можете просто да заредите код, който искате да добавите към клас в C# чрез директива за препроцесор, както бихте направили в C.

Можете обаче да дефинирате интерфейс и да декларирате методи за разширение за този интерфейс. След това интерфейсът може да бъде имплементиран от вашите класове и можете да извиквате методите за разширение на тези класове. напр.

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!");
    }
}

Това би ви позволило да използвате повторно функционалност, но не можете да получите достъп до частните членове на класа, както бихте могли, ако можехте, да речем, хешът да включва файл.

Все пак може да се нуждаем от по-конкретни примери за това, което искате да направите?

C# помощен клас ще работи. Той действа като централен регистър за общ код (или като конструкцията на модула VB.NET) - трябва да съдържа код, който не е специфичен за нито един клас, в противен случай трябва да е прикачен към съответния клас.

Вие не искате да започнете да копирате изходния код наоколо, ако не се налага, защото това би довело до проблеми с актуализирането на кода предвид дублирането.

Докато източникът не трябва да запазва състояние, използвайте статичен клас със статичен метод.

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

Ако класовете са в едно и също пространство от имена, няма нужда от аналог за включване. Просто извикайте членовете на класа, дефиниран в другата функция.

Ако не са в едно и също пространство от имена, добавете пространството от имена на класовете, които искате да използвате в директивите за използване и трябва да работи по същия начин като по-горе.

Объркан съм от въпроса: изглежда, че трябва да поработите върху основното си OO разбиране.

Методи за разширение на Checkout: http://msdn.microsoft.com/en-us/library/bb383977.aspx

Не знам за начин за включване на части от файлове, но едно нещо, което правим често, е да добавим съществуващ файл и да го „свържем“ от текущото му местоположение. Например имаме файл assemblyInfo.cs, към който препраща всеки проект от директория за решение. Променяме го веднъж и всички проекти имат една и съща информация, защото препращат към един и същ файл.

В противен случай предложенията за рефакторинг на "общи" рутинни процедури в common.dll са най-доброто нещо, което съм измислил в .Net.

Вече не съм сигурен какво точно имате предвид под „смислена“ структура, но това звучи като място, където можете да използвате внедряване на базов клас. Въпреки че не е толкова "подробен" като множественото наследяване на C++, може да извлечете известна полза от използването на верижна имплементация на базов клас за повторно използване на общи функции.

Можете да запазите йерархията на класовете, поне визуално и да замените поведението, ако е необходимо.

Изтеглете повтарящия се код в услугите. Повтарящият се код е улика, че може да има място за рефакторинг.

Например, създайте "PrintingService", която съдържа логиката, необходима за печат. След това можете да накарате класовете, които трябва да се отпечатат, да имат зависимост от тази услуга (или чрез конструктора, или чрез параметър в метод, който изисква услугата).

Друг съвет, който имам в тази насока, е да създам интерфейси за основна функционалност и след това да използвам интерфейсите за кодиране. Например, имах куп класове отчети, които потребителят можеше да изпрати по факс, по имейл или да отпечата. Вместо да създавам методи за всеки, създадох услуга за всеки, накарах ги да внедрят интерфейс, който имаше един метод на Output(). След това бих могъл да предам всяка услуга към един и същ метод в зависимост от това какъв вид изход иска потребителят. Когато клиентът искаше да използва eFax вместо да изпраща факс през модема, беше просто въпрос на написване на нова услуга, която внедрява същия този интерфейс.

Честно казано, не мога да се сетя за нещо подобно на включването във Visual C#, нито защо бихте искали тази функция. Въпреки това, частичните класове могат да направят нещо, сякаш звучи това, което искате, но използването им може би ще се сблъска с вашето изискване „класовете вече имат значима йерархия“.

Имате много опции, TT, метод на разширение, делегат и ламбда