Ne peut pas implémenter l'interface membre parce qu'il n'a pas la correspondance de type de retour de la Liste<IInterface>

J'ai interfaces IChild et IParent. IParent a un membre qui est un List<IChild>.

Je souhaite avoir des classes qui implémentent IParent où chaque classe a un membre qui met en œuvre IChild:

public interface IChild
{ 
}  

public interface IParent
{  
    List<IChild> a { get; set; }
} 

public class ChildA : IChild
{ 
} 

public class ChildB : IChild
{ 
} 

public class ParentA : IParent
{ 
    public List<ChildA> a { get; set; }
}

public class ParentB : IParent
{ 
    public List<ChildB> a { get; set; }
}

Mais, ce code ne compilera pas. L'erreur est:

`MyApp.Data.ParentA` does not implement interface member `MyApp.Data.IParent.a`.
`MyApp.Data.ParentA.a` cannot implement `MyApp.Data.IParent.a` because it does not have
the matching return type of `System.Collections.Generic.List<MyApp.Data.IChild>`.

Il serait plus sage de déclarer votre List propriétés ILists, ils seraient moins retrictive mais offre la même fonctionnalité. N'aide pas à la question.
ensuite, il peut faire juste IEnumerable. Peut-être pas à l'exigence
IList n'offre pas les mêmes fonctionnalités que List.
vous avez raison, mais, IList, ICollection (thier readonly) ou IEnumerable peut-être une petite promesse de faire qui ne satisfaire à l'exigence de niveau de fonctionnalité.

OriginalL'auteur Sergej Popov | 2012-08-14

c#generics inheritance interface

Faire IParent générique:

public interface IChild
{
}

public interface IParent<TChild> where TChild : IChild
{
    List<TChild> a { get; set; } 
}

public class ChildA : IChild {  }   

public class ChildB : IChild {  }   

public class ParentA : IParent<ChildA>
{
    public List<ChildA> a { get; set; }
}

public class ParentB : IParent<ChildB>
{
    public List<ChildB> a { get; set; }
}

Je souhaite vraiment que je pourrais upvote ce 100 fois...c'est une étude de cas sur pourquoi les génériques sont donc utiles.
Pouvez-vous élaborer sur les raisons pour lesquelles la solution?

OriginalL'auteur Volma

2

Vous avez besoin d'avoir le rendement des classes d'un List<IChild>:
```
public class ParentA : IParent
{ 
    public List<IChild> a { get; set; }
}

public class ParentB : IParent
{ 
    public List<IChild> a { get; set; }
}
```
Pas sûr de savoir pourquoi cela a été voté. Ce ne sera pas compilé. Vous ne pouvez pas convertir un List<ChildX> ou à partir d'un List<IChild>.
Vous avez raison. Mon erreur. J'ai édité la réponse.

OriginalL'auteur Garrett Vlieger

La mise en œuvre ne peut que retourner la Liste de IChild comme suit:

public interface IChild
{
}

public interface IParent
{
    List<IChild> Children { get; set; }
}

public class ChildA : IChild
{
}

public class ChildB : IChild
{
}

public class ParentA : IParent
{

    public List<IChild> Children
    {
        get;
        set;

    }
}

public class ParentB : IParent
{
    public List<IChild> Children
    {
        get;
        set;
    }
}

OriginalL'auteur nabeelfarid

0

Une collection de IChild ne peut pas être implicitement converti à une collection de son enfant type

Changer le type de retour de IParent.a à List<ChildA> OU modifier la déclaration de la propriété sur ParentA et ParentB à public List<IChild> a { get; set; }. Je vous recommande le dernier, je pense que c'est ce que vous êtes plus susceptibles d'aller pour.

Entendez-vous, de modifier les déclarations de propriété sur ParentA et ParentB? L'un sur IParent est déjà un List<IChild>.
Oui, vous devrez modifier les déclarations sur votre mise en œuvre de classes.

OriginalL'auteur mclark1129

J'ai eu une demande similaire où j'ai eu deux méthodes différentes qui fonctionne sur deux classes différentes, mais avait la même logique pour les propriétés qui sont communes pour les deux classes.

j'ai donc pensé à utiliser l'héritage et des génériques pour cela d'écrire une méthode commune, j'ai été en mesure d'atteindre de la manière suivante.

namespace OOPS.Interfaces
{
    using System.Collections.Generic;

    public interface IBanner
    {
        string Name { get; set; }
    }

    public interface IBannerContent<T> where T : IBanner
    {
        List<T> Banners { get; set; }
    }
}

Modèle Simple.

namespace OOPS.Simple
{
    using Interfaces;
    using System.Collections.Generic;

    public class Banner : IBanner
    {
        public string Name { get; set; }
    }

    public class BannerContent : IBannerContent<Banner>
    {
        public List<Banner> Banners { get; set; }
    }
}

Modèle Complexe.

namespace OOPS.Complex
{
    using Interfaces;
    using System.Collections.Generic;

    public class Banner : IBanner
    {
        public string Name { get; set; }

        public string Description { get; set; }
    }

    public class BannerContent : IBannerContent<Banner>
    {
        public List<Banner> Banners { get; set; }
    }
}

La commune de la logique métier et l'échantillon de l'invocation. La clé ici est d'utiliser la where clause de contraindre le type de comme la where T : IBanner tout le chemin vers le bas jusqu'à la méthode que nous voulons qu'il soit commun.

namespace OOPS
{
    using Interfaces;
    using System;
    using System.Collections.Generic;

    public class BusinessLogic
    {
        public void Print<T>(IBannerContent<T> bannerContent) where T : IBanner
        {
            foreach (var item in bannerContent.Banners)
            {
                Console.WriteLine(item.Name);
            }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var banner1 = new Simple.BannerContent
            {
                Banners = new List<Simple.Banner>
                {
                    new Simple.Banner { Name = "Banner 1" },
                    new Simple.Banner { Name = "Banner 2" }
                }
            };

            var banner2 = new Complex.BannerContent
            {
                Banners = new List<Complex.Banner>
                {
                    new Complex.Banner { Name = "Banner 3", Description = "Test Banner" },
                    new Complex.Banner { Name = "Banner 4", Description = "Design Banner" }
                }
            };

            var business = new BusinessLogic();
            business.Print(banner1);
            business.Print(banner2);
            Console.ReadLine();
        }
    }
}

OriginalL'auteur Abdul Mateen Mohammed

Vous devez vous connecter pour publier un commentaire.