Как использовать дженерики для заполнения моделей производных классов, чтобы избежать дублирования кода?

У меня есть 2 типа, и каждый тип имеет разную логику обработки. На основании этой обработки я готовлю результат и возвращаю его потребителю (приложение mvc, консольное приложение и т.д.)

Теперь проблема в том, что некоторый код является общим для обоих типов. Единственная часть, которая отличается, - это класс (Type1Manager,Type2Manager) для обоих типов, который фактически содержит логику для обработки type1 and type2 и подготовки результата (Type1Model,Type2Model).

Проблема здесь, с которой я сталкиваюсь, заключается в том, что для Type1 needs Type1Model а для Type2 needs Type2Model. Даже если я попытаюсь BaseManager общий код в своем классе BaseManager, как бы я Type1Model and Type2Model модели Type1Model and Type2Model? Часть, с которой я борюсь, - это рефакторинг кода для обоих типов и перемещение некоторой общей логики в базовый класс.

Можно ли реорганизовать дубликаты кода для обоих типов и переместить их в базовый класс?

Ответы

Ответ 1

Вы можете перенести большую часть кода в базовый класс, если сделаете базовый класс универсальным и установите правильные ограничения. Кроме того, вам нужно создать конкретную реализацию для каждого типа.
Следующий пример должен дать вам представление:

public abstract class SharedLogicClass<TValue, TType>
  where TType : BaseModel<TValue>, new
{
    public override ExecutionResult GetExecutionResult(Variant model)
    {
      var executionResult = new ExecutionResult();
      executionResult.Name = model.Name;
      var type1Result = new List<TTYpe>();
      try
      {
        for (int counter = 0; counter < model.Subvariants.Count - 1; counter++) 
        {
          var left = model.Subvariants.Count[counter];
          var right = model.Subvariants.Count[counter + 1];
          using (var t = CreateTypeManager(model))
          {
            for (int i = 0; i < 2; i++)
            {
              if (i == 0)
              {
                t.Start(i);
                if (counter == 0)
                {
                  type1Result.Add(new TType()
                  {
                    Name = left.Name,
                    Value = t.LeftValue
                  });
                }
              }
              else
              {
                t.Start(i);
                var type = new TType()
                {
                  Name = right.Name,
                  Value = t.RightValue,
                  Coordinates = t.Left + t.Right,
                  OverAllPercentage = t.OverAllPercentage,
                });
                AssignAdditionalValues(type, t);
                type1Result.Add(type);
              }
            }
          }
        }
        AssignExecutionResult(executionResult, type1Result);
      }
      catch (Exception ex)
      {
        executionResult.Success = false;
        executionResult.ErrorMessage = ex.Message;
      }
      return executionResult;
    }
    protected abstract BaseManager CreateTypeManager(Variant model);
    protected virtual void AssignAdditionalData(Type1Model type, TypeManager t) {}
    protected abstract void AssignExecutionResultList(ExecutionResult res, IList<TType> lst);
}

public class SharedLogicImplementationType1 : SharedLogicClass<int, Type1Model>
{
  protected override BaseManager CreateTypeManager(Variant model)
  {
    return new Type1Manager(model);
  }

  protected override void AssignAdditionalData(Type1Model type, TypeManager t)
  {
    type.PerformanceCounter = (t.NetPlus + t.AverageRatio);
    type.MiscPercentage = t.MiscPercentage;
  }

  protected override void AssignExecutionResultList(ExecutionResult res, IList<Type1Model> lst)
  {
    res.Types1 = lst;
  }
}


public class SharedLogicImplementationType2 : SharedLogicClass<decimal, Type2Model>
{
  protected override BaseManager CreateTypeManager(Variant model)
  {
    return new Type2Manager(model);
  }

  protected override void AssignExecutionResultList(ExecutionResult res, IList<Type2Model> lst)
  {
    res.Types2 = lst;
  }
}

Пожалуйста, рассматривайте код как образец, а не как законченную работу.

Ответ 2

Ваша объектная модель действительно слишком. Мне удалось удалить большую часть дублирования, но с именами классов трудно предложить дальнейший рефакторинг. Я подозреваю, что вы делаете это трудным путем.

Вот что у меня есть:

public class Variant
{
    public int Id { get; set; }
    public string Name { get; set; }
    public List<Subvariants> Subvariants { get; set; }
}

public class Subvariants
{
    public int Id { get; set; }
    public string Name { get; set; }
}

public class ExecutionResult<T, TModel>
    where TModel : BaseModel<T>
{
    public string Name { get; set; }
    public string ErrorMessage { get; set; }
    public bool Success { get; set; }
    public List<TModel> Types { get; set; }
}

public abstract class BaseModel<T>
{
    public string Name { get; set; }
    public T Value { get; set; }
    public T Coordinates { get; set; }
    public decimal OverAllPercentage { get; set; }
}

public class Type1Model : BaseModel<int>
{
    public decimal MiscPercentage { get; set; }
    public int PerformanceCounter { get; set; }
}

public class Type2Model : BaseModel<decimal> { }

public abstract class BaseManager<T, TManager, TModel, R>
    where TManager : TypeBaseManager<T>
    where TModel : BaseModel<T>
    where R : ExecutionResult<T, TModel>, new()
{
    protected abstract TManager CreateTypeManager(Variant model);
    protected abstract TModel CreateTypeModelLeft(TManager typeManager, Subvariants subvariant);
    protected abstract TModel CreateTypeModelRight(TManager typeManager, Subvariants subvariant);

    public R GetExecutionResult(Variant model)
    {
        var executionResult = new R();
        executionResult.Name = model.Name;
        var type1Result = new List<TModel>();
        try
        {
            for (int counter = 0; counter < model.Subvariants.Count - 1; counter++)
            {
                var left = model.Subvariants[counter];
                var right = model.Subvariants[counter + 1];
                using (var t = CreateTypeManager(model))
                {
                    for (int i = 0; i < 2; i++)
                    {
                        if (i == 0)
                        {
                            t.Start(i);
                            if (counter == 0)
                            {
                                type1Result.Add(CreateTypeModelLeft(t, left));
                            }
                        }
                        else
                        {
                            t.Start(i);
                            type1Result.Add(CreateTypeModelRight(t, right));
                        }
                    }
                }
            }
            executionResult.Types = type1Result;
        }
        catch (Exception ex)
        {
            executionResult.Success = false;
            executionResult.ErrorMessage = ex.Message;
        }
        return executionResult;
    }
}

public class Type1 : BaseManager<int, Type1Manager, Type1Model, ExecutionResult<int, Type1Model>>
{
    protected override Type1Manager CreateTypeManager(Variant model)
    {
        return new Type1Manager(model);
    }

    protected override Type1Model CreateTypeModelLeft(Type1Manager typeManager, Subvariants subvariant)
    {
        return new Type1Model
        {
            Name = subvariant.Name,
            Value = typeManager.Left
        };
    }

    protected override Type1Model CreateTypeModelRight(Type1Manager typeManager, Subvariants subvariant)
    {
        return new Type1Model
        {
            Name = subvariant.Name,
            Value = typeManager.Right,
            Coordinates = typeManager.Left + typeManager.Right,
            OverAllPercentage = typeManager.OverAllPercentage,
            PerformanceCounter = (typeManager.NetPlus + typeManager.AverageRatio),
            MiscPercentage = typeManager.MiscPercentage
        };
    }
}

public class Type2 : BaseManager<decimal, Type2Manager, Type2Model, ExecutionResult<decimal, Type2Model>>
{
    protected override Type2Manager CreateTypeManager(Variant model)
    {
        return new Type2Manager(model);
    }

    protected override Type2Model CreateTypeModelLeft(Type2Manager typeManager, Subvariants subvariant)
    {
        return new Type2Model { Name = subvariant.Name, Value = typeManager.Left };
    }

    protected override Type2Model CreateTypeModelRight(Type2Manager typeManager, Subvariants subvariant)
    {
        return new Type2Model
        {
            Name = subvariant.Name,
            Value = typeManager.Right,
            Coordinates = typeManager.Left + typeManager.Right,
            OverAllPercentage = typeManager.OverAllPercentage,
        };
    }
}

public class TypeBaseManager<T> : IDisposable
{
    protected Variant model;
    public T Right { get; private set; }
    public T Left { get; private set; }
    public decimal OverAllPercentage { get; private set; }
    public TypeBaseManager(Variant model)
    {
        this.model = model;
    }

    public void Start(int i)
    {
    }

    public void Dispose()
    {
        throw new NotImplementedException();
    }
}

public class Type1Manager : TypeBaseManager<int>
{
    public int NetPlus { get; private set; }
    public int AverageRatio { get; private set; }
    public decimal MiscPercentage { get; private set; }

    public Type1Manager(Variant model) : base(model) { }
}

public class Type2Manager : TypeBaseManager<decimal>
{
    public Type2Manager(Variant model) : base(model) { }
}

Мне бы очень хотелось, чтобы вы переименовали классы с некоторой последовательностью.

Кроме того, я хотел бы, чтобы catch (Exception ex) удален - не похоже, что ваш код может потерпеть там неудачу, и если это возможно, похоже, что вы можете кодировать ошибку, не прибегая к обработке исключений. В конце концов, обработка исключений должна быть для обработки исключительных ситуаций, таких как нехватка места на жестком диске.