Surcharger les méthodes génériques

Lors de l'appel d'une méthode générique pour le stockage d'un objet, il y a parfois besoin de gérer un type spécifique différemment. Je sais que vous ne pouvez pas surcharge basée sur les contraintes, mais aucune autre alternative semble présenter ses propres problèmes.

public bool Save<T>(T entity) where T : class
{ ... some storage logic ... }

Ce que j'aimerais faire, c'est quelque chose comme ce qui suit:

public bool Save<SpecificClass>(T entity)
{ ... special logic ... }

Dans le passé, notre équipe a créé "one-off" méthodes pour l'enregistrement de ces classes comme suit:

public bool SaveSpecificClass(SpecificClass sc)
{ ... special logic ... }

Toutefois, si vous ne SAVEZ pas que la fonction existe, et vous essayez d'utiliser le générique (Enregistrer) ensuite, vous pouvez exécuter dans une foule de problèmes que le "one-off" était censé résoudre. Cela peut être aggravé si un nouveau développeur qui vient, voit le problème avec les génériques, et décide qu'il va fixer avec son propre d'une fonction d'arrêt.

Donc...

Quelles sont les options pour travailler autour de ce qui semble être question commune?

Que j'ai regardé, et utilisé UnitOfWork et maintenant ce qui semble être la seulement option qui en fait résout le problème, mais semble comme attaquant une mouche avec un marteau de forgeron.

source d'informationauteur Patrick Dench

c#generics overloading

Que vous pouvez faire :

public bool Save<T>(T entity) where T : class
{ ... some storage logic ... }

public bool Save(SpecificClass entity)
{ ... special logic ... }

Par exemple:

public class SpecificClass
{
}

public class Specializer
{
    public bool GenericCalled;
    public bool SpecializedCalled;

    public bool Save<T>(T entity) where T : class
    {
        GenericCalled = true;
        return true;
    }

    public bool Save(SpecificClass entity)
    {
        SpecializedCalled = true;
        return true;
    }
}

public class Tests
{
    [Test]
    public void TestSpecialization()
    {
        var x = new Specializer();
        x.Save(new SpecificClass());
        Assert.IsTrue(x.SpecializedCalled);
        Assert.IsFalse(x.GenericCalled);
    }
}

3

Parce que la fonction et la surcharge de l'opérateur impliquant les génériques sont liés au moment de la compilation plutôt qu'au moment de l'exécution, si le code a deux méthodes:
```
public bool Save<T>(T entity) ...
public bool Save(SomeClass entity) ...
```
alors le code qui tente de l'appeler Save(Foo) où Foo est une variable de certains type générique sera toujours appeler l'ancien surcharge, même lorsque le type générique qui arrive à être SomeClass. Ma suggestion pour résoudre serait de définir une interface générique ISaver<in T> avec une non-méthode générique DoSave(T param). Avoir la classe qui fournit l' Save méthode de mettre en œuvre toutes les interfaces génériques pour les types qu'il peut gérer. Alors l'objet Save<T> méthode essayez de lancer this à un ISaver<T>. Si le sort réussit, l'utilisation de la ISaver<T>; sinon effectuer un générique enregistrer. À condition que le type de classe de la déclaration de la liste de toutes les interfaces appropriées pour les types il peut sauver, cette approche permettra d'expédition Save les appels aux méthodes appropriées.

Bien bref C# ne permet pas de modèle de spécialisation, sauf par le biais de l'héritage comme ceci:

interface IFoo<T> { }
class Bar { }

class FooBar : IFoo<Bar> { }

Au moins il ne prend pas en charge ce cours moment de la compilation. Cependant, vous pouvez utiliser le RTTI pour faire ce que vous essayez d'atteindre:

public bool Save<T>(T entity)
{
    //Check if "entity" is of type "SpecificClass"
    if (entity is SpecificClass)
    {
        //Entity can be safely casted to "SpecificClass"
        return SaveSpecificClass((SpecificClass)entity);
    }

    //... other cases ...
}

La expression est assez pratique pour faire runtime type de contrôles. Il fonctionne de manière similaire au code suivant:

if (entity.GetType() == typeof(SpecificClass))
    //...

MODIFIER : Il est assez commun pour les types inconnus à utiliser le modèle suivant:

if (entity is Foo)
    return DoSomethingWithFoo((Foo)entity);
else if (entity is Bar)
    return DoSomethingWithBar((Bar)entity);
else
    throw new NotSupportedException(
        String.Format("\"{0}\" is not a supported type for this method.", entity.GetType()));

EDIT 2 : Comme les autres réponses suggèrent surcharge la méthode avec le SpecializedClass vous devez prendre soin de si vous travaillez avec le polymorphisme. Si vous utilisez des interfaces pour votre référentiel (qui est en fait une bonne manière de concevoir le modèle de référentiel) il y a des cas où la surcharge conduirait à des cas dans lesquels vous êtes à la mauvaise méthode de obtenir ce qu'on appelle, peu importe si vous êtes de passage à un objet de SpecializedClass à l'interface:

interface IRepository
{
    bool Save<T>(T entity)
        where T : class;
}

class FooRepository : IRepository
{
    bool Save<T>(T entity)
    {
    }

    bool Save(Foo entity)
    {
    }
}

Cela fonctionne si vous appelez directement FooRepository.Save avec une instance de Foo:

var repository = new FooRepository();
repository.Save(new Foo());

Mais cela ne fonctionne pas si vous appelez de l'interface (par exemple, si vous utilisez des modèles pour mettre en œuvre la création de référentiel):

IRepository repository = GetRepository<FooRepository>();
repository.Save(new Foo());  //Attention! Call's FooRepository.Save<Foo>(Foo entity) instead of FooRepository.Save(Foo entity)!

Utilisant le RTTI il n'y a qu'un Save méthode et vous serez amende.

Pourquoi utiliser des noms différents pour votre méthode?

Voir la suivante:

    public class Entity
    {
    }

    public class SpecificEntity : Entity
    {
    }

    public class Program
    {
        public static void Save<T>(T entity)
            where T : class
        {
            Console.WriteLine(entity.GetType().FullName);
        }

        public static void Save(SpecificEntity entity)
        {
            Console.WriteLine(entity.GetType().FullName);
        }

        private static void Main(string[] args)
        {
            Save(new Entity());          //ConsoleApplication13.Entity
            Save(new SpecificEntity());  //ConsoleApplication13.SpecificEntity

            Console.ReadKey();
        }
    }

Vous devez vous connecter pour publier un commentaire.