NRules: कस्टम बेस क्लास के साथ नियम पर DSL एक्सटेंशन का उपयोग करने वाली समस्या

मैं नियमों को परिभाषित करने के लिए NRules का उपयोग कर रहा हूं जो सभी एक सामान्य आधार वर्ग से प्राप्त होते हैं, जो स्वयं Rule से प्राप्त होते हैं।

जब मैं एक नए तथ्य को सम्मिलित करने के लिए एक डीएसएल एक्सटेंशन का उपयोग करता हूं जो एक मेल खाने वाली वस्तु को लपेटता है, ऐसा लगता है कि मिलान की गई वस्तु को विस्तार विधि में पारित किया गया है null।

यहां एक आत्मनिर्भर उदाहरण दिया गया है जो समस्या का प्रदर्शन करना चाहिए। मैं दो नियमों को परिभाषित करने के लिए xUnit परीक्षण ढांचे का उपयोग कर रहा हूं, प्रत्येक समान परीक्षण के साथ। पहला पास हो जाता है, दूसरा फेल हो जाता है।

using NRules;
using NRules.Fluent;
using NRules.Fluent.Dsl;
using Xunit;
using System.Linq;
using System.Reflection;

namespace IntegrationTests.Engine
{
    // A simple domain model
    public interface IFruit { }

    public class Apple : IFruit { }

    public class Basket
    {
        public Basket(IFruit apple)
        {
            MyApple = apple;
        }

        public IFruit MyApple { get; private set; }
    }


    // A base class for the rules
    public abstract class RuleBase : Rule
    {
        public override void Define()
        {
            // Empty
        }
    }

    // The first rule, which does not use the extension:
    public class TestRule : RuleBase
    {
        public override void Define()
        {
            base.Define();

            Apple a = null;
            When()
                .Match(() => a);

            Then()
                .Do(ctx => ctx.Insert(new Basket(a)));
        }
    }

    // The second rule, which uses an extension to add a new fact
    public class TestRuleWithExtension : RuleBase
    {
        public override void Define()
        {
            base.Define();

            Apple apple = null;
            When()
                .Match(() => apple);

            Then()
                .AddToBasket(apple);
        }
    }

    // The DSL extension
    public static class DslExtensions
    {
        public static IRightHandSideExpression AddToBasket(this IRightHandSideExpression rhs, IFruit fruit)
        {
            return rhs.Do(ctx => ctx.Insert(new Basket(fruit)));
        }
    }

    // The tests
    public class ExtensionTest
    {
        // This one tests the first rule and passes
        [Fact]
        public void TestInsert()
        {
            //Load rules
            var repository = new RuleRepository();
            repository.Load(x => x
                .From(Assembly.GetExecutingAssembly())
                .Where(rule => rule.Name.EndsWith("TestRule")));

            //Compile rules
            var factory = repository.Compile();

            //Create a working session
            var session = factory.CreateSession();

            //Load domain model
            var apple = new Apple();

            //Insert facts into rules engine's memory
            session.Insert(apple);

            //Start match/resolve/act cycle
            session.Fire();

            // Query for inserted facts
            var bananas = session.Query<Basket>().FirstOrDefault();

            // Assert that the rule has been applied
            Assert.Equal(apple, bananas.MyApple);
        }

        // This one tests the second rule, and fails
        [Fact]
        public void TestInsertWithExtension()
        {
            //Load rules
            var repository = new RuleRepository();
            repository.Load(x => x
                .From(Assembly.GetExecutingAssembly())
                .Where(rule => rule.Name.EndsWith("TestRuleWithExtension")));

            //Compile rules
            var factory = repository.Compile();

            //Create a working session
            var session = factory.CreateSession();

            //Load domain model
            var apple = new Apple();

            //Insert facts into rules engine's memory
            session.Insert(apple);

            //Start match/resolve/act cycle
            session.Fire();

            // Query for inserted facts
            var bananas = session.Query<Basket>().FirstOrDefault();

            // Assert that the rule has been applied
            Assert.Equal(apple, bananas.MyApple);
        }
    }
}

सवाल यह है कि डीएसएल एक्सटेंशन वाला दूसरा नियम ठीक से काम क्यों नहीं करता है? क्या मैं कुछ गलत कर रहा हूँ और मैं इसे कैसे ठीक कर सकता हूँ?