How to control Type conversion in C#

Question

Hi,

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 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,

Answer 1

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.

Answer 2

What about conversion operator:

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

Answer 3

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

You could also consider using AutoMapper for the task.

Answer 4

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

Answer 5

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

Answer 6

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