Конструктор C # с аргументом в универсальном типе в сочетании с интерфейсом

Question

Хорошо, поехали!Я пытаюсь сделать то, чего никогда не пробовал раньше, и ... C # укусил меня.

Дело в том, что моей программе нужно преобразовывать некоторые входные объекты в выходные объекты, причем многие в один выходили за раз.И нам нужен экземпляр для инстанциирования.

Я не уверен, что в данный момент я очень ясен ... Так что пример, иллюстрирующий это, будет лучше:

public class Class1
{
    public interface ITranslatable { }

    public interface ITranslatable<T> { }

    public class OriginClass : ITranslatable { }

    public class TargetClass : ITranslatable<OriginClass>
    {
        public TargetClass(OriginClass origin)
        {
            // Instantiate some properties from arg
        }
    }

    public class Test
    {
        public Y Execute<X, Y>(X origin, Y target)
            where X : ITranslatable
            where Y : ITranslatable<X>, new()
        {
            target = new Y(origin); // <= How can I make this
            // Some stuff
            return target;
        }
    }

    public TargetClass Function(OriginClass origin, TargetClass target)
    {
        var test = new Test();
        return test.Execute(origin, target);
    }
}

Answer 1

После нескольких попыток я нашел решение: используйте абстрактный класс.

Решение:

public class Class1
{
    public interface ITranslatable { }

    public interface ITranslatableOut
    {
        ITranslatable Origin { set; }
    }

    public class OriginClass : ITranslatable
    {
        public string Custom { get; set; }
    }

    public abstract class TargetBase : ITranslatableOut
    {
        public ITranslatable Origin { set { Initialize(value); } }

        protected abstract void Initialize(ITranslatable input);
    }

    public class TargetClass : TargetBase
    {
        protected override void Initialize(ITranslatable input)
        {
            // Initialize some properties
        }
    }

    public class Test
    {
        public Y Execute<X, Y>(X origin, Y target)
            where X : ITranslatable
            where Y : ITranslatableOut, new()
        {
            target = new Y { Origin = origin }; // It works !
            // Some stuff
            return target;
        }
    }

    public TargetClass Function(OriginClass origin, TargetClass target)
    {
        var test = new Test();
        return test.Execute(origin, target);
    }
}

Answer 2

Вы объявили ограничение new (), которое означает, что вы ожидаете, что класс будет иметь конструктор empy без параметров.

Подходит ли вам приведенный ниже код?

 public class Class1
{
    public interface ITranslatable { }

    public interface ITranslatable<T>
    {
        T Origin { get; set; }
    }

    public class OriginClass : ITranslatable
    {

    }

    public class TargetClass : ITranslatable<OriginClass>
    {
        private OriginClass _origin;

        public OriginClass Origin
        {
            get => _origin;
            set
            {
                //Do some stuff
                _origin = value;
            }
        }

        public TargetClass()
        {

        }

    }

    public class Test
    {
        public Y Execute<X, Y>(X origin, Y target)
            where X : ITranslatable
            where Y : ITranslatable<X>, new()
        {
            var result = new Y {Origin = origin};

            // Some stuff
            return target;
        }
    }

    public TargetClass Function(OriginClass origin, TargetClass target)
    {
        var test = new Test();
        return test.Execute(origin, target);
    }
}