Provide implicit operator for <T>

[TheOptimist]

Put an implicit operator for type on Faker so that I can do this:

public Faker<Thing> NormalThing = new Faker<Thing>
  .RuleFor(t => t.Name, f => f.Name.FirstName);

public Faker<Thing> HackerThing = DefaultThing
  .RuleFor(t => t.Handle, f => f.Hacker.Verb);

Thing normalThing = HackerThing;

Without the implicit operator, I either have to Generate in the consumer all the time, or copy various rules around the codebase. All the implicit operator would do is call Generate() - ShouldWork (tm).

If I get some time over the next week or so I'll try and code this up and send over a PR. Check this articule from Kenneth Truyers for more of an insight.

[bchavez]

Hi @TheOptimist ,

Would using the RuleSets feature in Bogus work in your scenario?

[Test]
public void issue_41()
{
    var faker = new Faker<Thing>()
        .RuleFor(t => t.Name, f => f.Name.FirstName())
        .RuleSet("HackerThing", set =>
            {
                set.RuleFor(t => t.Handle, f => f.Hacker.Verb());
            });

    var hackerThing = faker.Generate("default,HackerThing");
    hackerThing.Dump()
}

{
  "Name": "Lee",
  "Handle": "bypass"
}

🌾 🍲 _"Out here in the fields... I fight for my meals... It's only teenage wasteland..."_

[TheOptimist]

Hey @bchavez - that's nice. Thanks for the education :-) The key bit (for me) that's still missing from that is that I have to call Generate myself.

Thing thing = faker.Thing;
should be equivalent to
var Thing = faker.Thing.Generate();

So...

[Test]
public void issue_41_ImpliciCast()
{
    var fakeThing = new Faker<Thing>()
        .RuleFor(t => t.Name, f => f.Name.FirstName());

    Thing thing = fakeThing;
    AssertAreEqual(thing, fakeThing.Generate());
    thing.Dump()
}
{
  "Name": "Lee"
}

You can now do the following:

var fakeStudent = new Faker<Person>
  .RuleFor(p => p.Role, f => "student");

// Implicit cast calls generate on the faker
Person student = fakeStudent;

// But I can still control the generation on the faker
var students = fakeStudent.Generate(5);

// I can also tweak it
Person teacher = fakeStudent
  .RulfeFor(p => p.Role, f => "teacher");

// And still control the generation
var teachers = fakeStudent
  .RuleFor(p => p.Role, f => "teacher")
  .Generate(5);

If this doesn't get us closer to a mutual understanding I'll put some time aside this week to write up a few tests and send out a PR - might even be the easiest way of demonstrating the concept, and integrating if it's decided a good enough feature :)