C # type de conversion

Question

J'ai deux objets. Objet A et B objet.

L'objet A est une instance d'une classe qui a été générée à partir de plusieurs fichiers XSD. Xsd.exe occasion / c et les a compilés. Maintenant, j'ai mon nouvel objet.

J'ai aussi un service Web, retournant quelque chose de très similaire à l'objet A. Donc maintenant j'ai quelque chose le long des lignes de ceci:

WebService.foo myResponseObj = MyService.GetObject(inData);
MyFramework.foo myClientObj = new MyFramework.foo();

Ce que je veux faire est la

myClientObj = (MyFramework.foo)myResponseObj

Cependant, ce n'est pas vraiment aimer cela. « Impossible de convertir implicitement MyFramework.foo [] pour WebService.foo []

Toutes les idées sur la façon de résoudre ce problème? L'objet est assez grand et ils sont essentiellement identiques.

Answer 1

Comment à extraire l'interface (clic droit sur une classe, sélectionnez Refactor-> Extraire l'interface), et appliquer cette interface pour les deux classes?

Il ressemblera à quelque chose comme:

namespace WebService
{
   public class foo : IExtractedInterface
}

et

namespace MyFramework
{
   public class foo : IExtractedInterface
}

Vous devriez alors être en mesure de le faire:

IExtractedInterface myClientObj = (IExtractedInterface)myResponseObj;

Answer 2

Les deux objets devrait hériter de la même interface afin de réaliser avec succès la distribution que vous avez spécifié. Vous pouvez regarder en tirant la méthode commune (s) dont vous avez besoin dans une interface qui peut être mis en œuvre dans les deux classes, de cette façon, vous pouvez simplement jeter le type d'interface et avoir accès à seulement ces méthodes plutôt que l'objet entier.

Amusez-vous!

Answer 3

Vous devez faire une méthode qui convertit une classe dans l'autre en copiant manuellement toutes les propriétés.

Vous pouvez ensuite appeler cette méthode dans Array.ConvertAll.

Answer 4

eux étant « essentiellement identique » est insuffisante. Vous ne pouvez lancer entre deux objets si elles sont de type compatible, ce qui signifie qu'ils partagent un descendant commun et les types réels sont valables pour la coulée.

Par exemple, les travaux suivants si Circle est un descendant de Shape:

Shape x = new Circle();
Circle y = (Circle)x;

Cependant, ce qui suit pas événement de travail si ClassA et ClassB ont exactement les mêmes champs, mais ne sont pas réellement descendus les uns des autres:

ClassA a = new ClassA();
ClassB b = (ClassA)a;

Il peut être utile de les rendre à la fois mettre en œuvre une interface commune, alors vous pourriez lancer à cette interface et de les utiliser comme vous le souhaitez.

Answer 5

Cela a été essentiellement a déjà répondu . Il faut toutefois noter qu'en plus de ce qui a été répondu ici, il y a une petite lueur d'espoir fourni par nouvelle fonctionnalité « Type Equivalence » de .NET 4:

Notez cependant que C # 4 soutiendra un limité forme de typage structurel sur interfaces. Voir http :. //blogs.msdn.com/samng/archive/2010/01/24/the-pain-of-deploying-primary-interop-assemblies.aspx pour plus de détails

Ceci est assez avancé .NET-foo, cependant.

Answer 6

Si vous utilisez l'outil standard de wsdl.exe pour créer votre proxy et les classes de soutien, alors je crois qu'il génère le code sous forme de classes partielles. Si tel est votre cas, vous pouvez insérer votre propre opérateur de conversion implicite à l'un des types. Par exemple, supposons que vous avez votre classe MyService.foo définie dans le fichier « MyService \ foo.cs » comme ci-dessous:

namespace MyService
{
    public partial class foo
    {
        public string PropertyA { get; set; }
        public string PropertyB { get; set; }
        public string PropertyC { get; set; }
        // ...
    }
}

Et vous avez votre classe MyFramework.foo définie dans le fichier "MyFramework \ foo.cs" comme ci-dessous:

namespace MyFramework
{
    public class foo
    {
        public string PropertyA { get; set; }
        public string PropertyB { get; set; }
        public string PropertyC { get; set; }
        // ...
    }
}

Ensuite, vous pouvez créer un fichier séparé, disons que « MyService \ foo.conversion.cs » comme ci-dessous:

namespace MyService
{
    partial class foo
    {
        public static implicit operator MyFramework.foo(foo input)
        {
            return new MyFramework.foo
            {
                PropertyA = input.PropertyA,
                PropertyB = input.PropertyB,
                PropertyC = input.PropertyC,
                // ...
            };
        }
    }
}

Et qui vous permettra d'écrire plus de votre code à l'aide d'un objet MyService.foo comme si elle était un objet MyFramework.foo. Le code suivant compile avec la configuration ci-dessus:

        MyService.foo x = new MyService.foo();

        MyFramework.foo y = x;

Answer 7

S'il est un tableau, que la citation que vous avez donné l'indique, vous devez parcourir la collection de réponse et d'ajouter les objets membres dans la collection client.