How to control Type conversion in C#

Is there a way to control the type conversion in C#? So for example, if I have two types with essentially the same details, but one is used for the internal working of my application and the other is a DTO used for communicating with non-.Net applications:

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; }
}

Right now, I need to create a new instance of PlayerDTO from my Player instance every time and I'm开发者_StackOverflow中文版 looking for a better, cleaner way of doing this. One idea I had was to add an AsPlayerDTO() method to the player class, but would be nice if I can control the type conversion process so I can do this instead:

var playerDto = player as PlayerDTO; 

Anyone know if this is possible and how I might be able to do it?

Thanks,

You can implement an explicit convesion operator between the two types.

You could also consider using AutoMapper for the task.

You can implement either implicit or explicit type conversion: http://msdn.microsoft.com/en-us/library/ms173105.aspx.

Alternately, if you want to avoid making each class having to know about the other, you can use either custom mapping or an existing mapping library like AutoMapper.

What about conversion operator:

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

You'll still have to do the code to create the DTO object, but you can overload the cast operator to cast from your implementation object to the DTO object. You can even make an implicit cast.

see overloading cast and implicit

You can use explicit type conversions.

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;
  }
}

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

Sounds like you should be using an interface.

Then cast to the interface: Example below

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

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

You would then use the IPlayer As the DTO object. I assume this is because the Player class does not exist in the other assembly and you do not want to more it. You could then use the IPlayer in a shared assembly... to transfer between assemblies.

Hope this helps... ;-)

Update

the Auto Mapper is a better route! I think