FA question

all my code.cs

namespace Project1
{
    using System.Collections;
    using System.Collections.Generic;

    using FluentAssertions;
    using FluentAssertions.Execution;
    using FluentAssertions.Primitives;

    public static class MyOwnAssertionsExtensions
    {
        public static MyOwnAssertions Should(this MyType subject)
        {
            return new MyOwnAssertions(subject);
        }
    }

    public class MyOwnAssertions : ReferenceTypeAssertions<MyType, MyOwnAssertions>
    {
        public MyOwnAssertions(MyType subject)
        {
            this.Subject = subject;
        }

        protected override string Context
        {
            get
            {
                return "mytype";
            }
        }

        public AndConstraint<MyOwnAssertions> ContainMagic()
        {
            // I have some additional asserts 
            Execute.Assertion
                .ForCondition(this.Subject.ContainsMagicString())
                .FailWith("No, there's no magic here");

            return new AndConstraint<MyOwnAssertions>(this);
        }

        public AndConstraint<MyOwnAssertions> Contain(string expected)
        {
            // and like to use some of the already existing ones.
            // I know there is a 
            // public AndWhichConstraint<TAssertions, T> Contain(T expected, string because = "", params object[] reasonArgs)
            // implementation in the GenericCollectionAssertions.
            // And I try to just refer it to that method with something like. But this leads to a endless recursive loop, because it uses my own Contain() implementation of course.
            this.Subject.Should().Contain(expected);

            // this line does the job. But is it how I should do it? Not sure if I miss something.
            this.Subject.As<IEnumerable<string>>().Should().Contain(expected);

            return new AndConstraint<MyOwnAssertions>(this);
        }
    }

    public class MyType : IEnumerable<string>
    {
        private const string Magic = "It's a kind of magic!";

        private readonly List<string> strings;

        public MyType()
        {
            this.strings = new List<string>();
        }

        public bool ContainsMagicString()
        {
            return this.strings.Contains(Magic);
        }

        public void AddString(string someText)
        {
            this.strings.Add(someText);
        }

        public void AddMagicString()
        {
            this.strings.Add(Magic);
        }

        public IEnumerator<string> GetEnumerator()
        {
            return this.strings.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return this.GetEnumerator();
        }
    }
}

ExtensionMethodApproach.cs

    public static class MyCollectionAssertionExtensions
    {
        public static AndConstraint<StringCollectionAssertions> ContainMagic(this StringCollectionAssertions assertions)
        {
            Execute.Assertion
                .ForCondition(assertions.Subject.As<MyType>().ContainsMagicString())
                .FailWith("No, there's no magic");

            return new AndConstraint<StringCollectionAssertions>(assertions);
        }
    }

ok, thanks