Jak kontrolować konwersję typu w C#

Question

Czy istnieje sposób kontrolowania konwersji typu w języku C#? Tak na przykład, jeśli mam dwa typy z zasadniczo takich samych informacji, ale służy do wewnętrznego funkcjonowania mojego wniosku, a drugi jest DTO używany do komunikacji z aplikacjami non-.Net:

public sealed class Player 
{ 
    public Player(string name, long score) 
    { 
    Name = name; 
    Score = score; 
    ID = Guid.NewGuid(); 
    } 

    public string Name { get; private set; } 

    public Guid ID { get; private set; } 

    public long Score { get; private set; } 
} 

public sealed class PlayerDTO 
{ 
    public PlayerDTO(string name, long score, string id) 
    { 
    Name = name; 
    Score = score; 
    ID = id; 
    } 

    public string Name { get; private set; } 

    // the client is not .Net and doesn't have Guid 
    public string ID { get; private set; } 

    public long Score { get; private set; } 
} 

Prawy teraz, za każdym razem muszę utworzyć nową instancję PlayerDTO z mojej instancji Player i szukam lepszego, czystszego sposobu robienia tego. Jednym z pomysłów było to, aby dodać metodę AsPlayerDTO() do klasy graczem, ale byłoby miło, gdyby można kontrolować proces konwersji typu, więc mogę to zrobić w zamian:

var playerDto = player as PlayerDTO; 

Ktoś wie, czy jest to możliwe i jak mógłbym to zrobić?

Dzięki,

Answer 1

można realizować zarówno bezpośrednia lub pośrednia konwersję typu: http://msdn.microsoft.com/en-us/library/ms173105.aspx.

Jeśli chcesz uniknąć sytuacji, w której każda klasa musi wiedzieć o drugiej, możesz użyć niestandardowego mapowania lub istniejącej biblioteki mapowania, takiej jak AutoMapper.

Answer 2

Co operatora konwersji:

public static explicit operator PlayerDTO (Player value)... 
public static implicit operator PlayerDTO (Player value)... 

Answer 3

można wdrożyć explicit convesion operator pomiędzy tymi dwoma typami.

Można również rozważyć użycie AutoMapper dla zadania.

Answer 4

Nadal będziesz musiał wykonać kod, aby utworzyć obiekt DTO, ale możesz przeciążyć operatora rzutowania, aby rzucić go z obiektu implementacji do obiektu DTO. Możesz nawet wykonać niejawną obsadę.

zobaczyć overloading cast i implicit

Answer 5

Można użyć explicit typu konwersji.

public sealed class Player { 
    public static explicit operator PlayerDTO(Player p) { 
    PlayerDTO dto; 
    // construct 
    return dto; 
    } 
} 

public sealed class PlayerDTO { 
    public static explicit operator Player(PlayerDTO dto) { 
    Player p; 
    // construct 
    return p; 
    } 
} 

Answer 6

Zastosowanie AutoMapper @http://www.codeplex.com/AutoMapper

Answer 7

Brzmi jak należy używać interfejsu.

Następnie oddanych do interfejsu: Przykład poniżej

public interface IPlayer 
{ 
    string Name { get; set; } 
} 
public class Player : IPlayer 
{ 
    string Name { get; set; } 
} 

IPlayer playerDto = player as IPlayer; 
Player player = Player(playerDto); 

byłoby wtedy użyć iPlayer jako obiekt DTO. Zakładam, że dzieje się tak dlatego, że klasa Player nie istnieje w innym zespole i nie chcesz jej więcej. Następnie można użyć odtwarzacza IP we współużytkowanym zestawie ... do przenoszenia między złożeniami.

Nadzieja to pomaga ... ;-)

Aktualizacja

#

Auto Mapper jest lepsza droga! Myślę, że