Такой характерный интерфейс как тип возврата?

У меня есть вопрос, что безопасный, что очень основная. То, что я не понимаю, для того, чтобы используется такой интерфейс как тип возврата. Это продолжать быть типом того же способа? Какая утилита у него есть?

public interface ISessions {
   <IEnumerable<User>> RetrieveUser(string userId);
}

IEnumerable<User> = RetrieveUser(x);
1
задан 11.07.2016, 22:13
3 ответа

Поскольку упоминает Леандро Туттини: Определив интерфейс возврата он дает тебе свободу в изменении типа конкретной информации, которую ты возвращаешь, не затрагивая того, кто призывает функциональность.

Подобно прибавлению, я буду давать тебе пример, считай, что у тебя есть следующий интерфейс:

public interface IVehiculo
{
    string ObtenerPlaca();
}

Интерфейс сама не делает многое, нет? А следовательно мы должны создавать компоненты (Названные vehiculos) для того, чтобы Ваше функционирование имело смысл:

public class Carro : IVehiculo
{
    private string _Placa;
    public Carro(string placa) { _Placa = placa; }
    public string ObtenerPlaca() { return this._Placa; }
}

Хорошо!, у нас есть наш класс Carro что решает поведение интерфейса IVehiculo, но... Как, если мы хотим сделать одну, что другое осуществление?

public class Motor : IVehiculo
{
    private string _Placa;
    private string _Modelo;
    public Motor(string placa, string modelo) { _Placa = placa; _Modelo = modelo; }
    public string ObtenerPlaca() { return this._Placa; }
    public string ObtenerModelo() { return this._Modelo; }
}

Ох! У нас есть два класса с тем же интерфейсом ¿ и одна более разработана, чем другая?

Итак, они получают в наследство оба IVehiculo, ты можешь тестировать следующий код в любом месте и оно ты будет функционировать так что все элементы, которые имеют интерфейс, могут иметь поведение:

using System.Collections.Generic;

public class Program
{
    // Definimos una que otra lista para hacerla "nuestra base de datos"
    public static List<IVehiculo> Vehiculos = new List<IVehiculo>()
    {
        new Carro("123-123-12"),
        new Motor("321-32-321", "Alguna marca"),
        new Motor("22-223-210", "Otra marca"),
        new Carro("222-3-23-2")
    };

    // Definición de la  función para obtener un motor.
    public static IVehiculo ObtenerMotorPorPlaca(string placa)
    {
        foreach (IVehiculo vh in Vehiculos)
        {
            if (vh.GetType() == typeof(Motor))
                if (vh.ObtenerPlaca() == placa) return vh;
        }
        return null;
    }

    // Inicio:
    public static void Main()
    {
        IVehiculo MiVehiculo = new Motor("21132", "wwq"); // Puedo definir un motor
        Console.WriteLine("Placa del motor: " + MiVehiculo.ObtenerPlaca() + " Modelo: " + ((Motor)MiVehiculo).ObtenerModelo());

        // Asi como puedo definir un carro:
        MiVehiculo = new Carro("23232");
        Console.WriteLine("Placa del motor: " + MiVehiculo.ObtenerPlaca());

        MiVehiculo = ObtenerMotorPorPlaca("321-32-321");
        Console.WriteLine("Placa del vehiculo buscado: " + MiVehiculo.ObtenerPlaca()); 
    }
}

Хотя это не самый практический пример, но служит для того, чтобы доказать, как функционируют интерфейсы.

Интерфейсы - что-то подобное печати, которая применяется к классу, чтобы помечать Ваше "Поведение", сказанное "безрассудным" способом. Класс, который осуществляет интерфейс, должен приносить все элементы этого интерфейса, чтобы разрабатывать Ваше поведение.

EDIT: Чтобы осветлять что-то.

У элементов с тем же осуществленным интерфейсом, есть главным образом то же поведение, но это не означает, что они были равны, в предыдущий пример я поместил интерфейс IVehiculo и другие два класса Motor и Carro, я это поместил по следующему разуму:

Следующая функция возвращает один Carro или один Motor завися Ваша плата.

public static IVehiculo ObtenerMotorPorPlaca(string placa)
{
    foreach (IVehiculo vh in Vehiculos)
    {
        if (vh.ObtenerPlaca() == placa) return vh;
    }
    return null;
}

И мы изменяем код метода Main() предыдущий и мы добавляем:

public static void Main()
{
    IVehiculo MiVehiculo = new Motor("21132", "wwq"); // Puedo definir un motor
    Console.WriteLine("Placa del motor: " + MiVehiculo.ObtenerPlaca() + " Modelo: " + ((Motor)MiVehiculo).ObtenerModelo());

    // Asi como puedo definir un carro:
    MiVehiculo = new Carro("23232");
    Console.WriteLine("Placa del motor: " + MiVehiculo.ObtenerPlaca());
    Console.WriteLine(MiVehiculo.GetType()); // Carro.      

    MiVehiculo = ObtenerMotorPorPlaca("321-32-321");
    Console.WriteLine("Placa del vehiculo buscado: " + MiVehiculo.ObtenerPlaca()); 
    Console.WriteLine(MiVehiculo.GetType()); // Motor,
}

Я добавил 2 GetType() чтобы подтверждать тип информации, использованный в обоих ассигнованиях, разуме, из-за которого никогда он не возвращает себе тип интерфейса, а тип класса, который "подписывает" контракт, осуществив этот интерфейс, чтобы принимать это поведение, однако, я смог возвращать различные типы той же функции, каждый раз, когда они осуществляют тот же интерфейс.


Какие-то ссылки ссылки: Интерфейсы, MSDN (английский язык), Один, что другой fiddle... (обновленный).

2
ответ дан 24.11.2019, 13:51
  • 1
    Но когда он возвращает interf и # 237; cie ген и # 233; богатая с classe User, уже возврати тип (IEnumerable< User> = RetrieveUser (x);), но только оно позволяет ему отображать м и # 233; все IEnumerable? Концепция интерфейса я понимаю то, что стоит мне понимания, это возврат интерфейса с классом. – gvivetapl 11.07.2016, 22:07
  • 2
    Если ты используешь интерфейс как тип возврата, ты предположен, чтобы мочь возвращать более одного типа, который осуществлял бы IEnumerable. Поскольку это случай коллекций в в.NET, если у тебя есть funci и # 243; n, что возвращает IEnumerable<T>, эта может возвращать один List<T>, любую вещь, которая осуществляла бы этот интерфейс. Только поворачивается ген и # 233; богатый стоимость, которая может возвращаться. – NaCl 11.07.2016, 22:46
  • 3
    Но во все это, что отличается habr и # 237; в, если автомобиль и мотоцикл получат в наследство от базового класса например Транспортное средство. Очевидно ObtenerMotorPorPlaca () tendr и # 237; в который возвращать тип базового класса. Просто поведение было бы точно тот же самый? – gvivetapl 15.07.2016, 16:48
  • 4
    @gvivetapplus Смотри изданного. – NaCl 15.07.2016, 17:05

Определив интерфейс возвращения он дает тебе свободу в изменении типа конкретной информации, которую ты возвращаешь, не затрагивая того, кто призывает функциональность

, Помнит, что классы, как то, чтобы быть List<> , они осуществляют ее поэтому ты мог бы возвращать ее как ответ, но не единственная

enumerador genГ©rico IEnumerable. Основы LINQ у II

года Также есть связь с linq, так как ты мог бы производить query и возвращать результат прямо, так как IQueryable<> также он осуществляет ее.

2
ответ дан 24.11.2019, 13:51
  • 1
    Тогда возвращать List< T> и IList< t> какие различия он предполагает? – gvivetapl 17.07.2016, 13:32

Интерфейс полезный в нескольких сценах, например, когда ты нуждаешься в том, чтобы послать извещение пользователю. Поведение должно получать два аргумента, сообщение и пользователь. Однако до этой точки то, что мы сделали, состоит в том, чтобы определять поведение. Это поведение - тот, которого мы определили бы в интерфейсе (ISender), таким образом что наша функция (Main) не была необходим, чтобы он узнал, кто и как он осуществляет ее.

class Program
{
    static void Main(string[] args)
    {
        ISender sender = new MailSender();
        sender.Send(1, "¡Hola mundo!");
    }
}

class MailSender : ISender
{
    public void Send(int userId, string mensaje)
    {
        // Aquí abriría una conexión SMTP y enviaría el correo.
    }
}

interface ISender
{
    void Send(int userId, string mensaje);
}

Полезное в этих случаях, состоит в том, что, если мы например нуждаемся в том, чтобы изменить осуществление, мы просто создаем новый класс, который осуществлял бы вышеупомянутый интерфейс.

class Program
{
    static void Main(string[] args)
    {
        ISender sender = new FileSender();
        sender.Send(1, "¡Hola mundo!");
    }
}

class FileSender : ISender
{
    public void Send(int userId, string mensaje)
    {
        // No envio el correo, solo lo guardo 
        // en un archivo
    }
}

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

class Program
{
    static void Main(string[] args)
    {
        // Obtenemos la clase que se encargará de realizar el trabajo.
        ISender sender = GetSender();
        sender.Send(1, "¡Hola mundo!");
    }

    static ISender GetSender()
    {
        // Podríamos haber usado FileSender o MailSender
        // Ambos implementan ISender.
        return new MailSender();
    }
}

Это единственный добавочный пример в тех, которые уже упомянули о тебе, я надеюсь, что он помогает тебе понимать использование интерфейсов.

Когда ты используешь Ninject для вставки зависимостей, ты наслаждаешься работы с интерфейсами.

Привет.

1
ответ дан 24.11.2019, 13:51

Теги

Похожие вопросы