{"id":4492,"date":"2019-03-04T23:50:46","date_gmt":"2019-03-05T04:50:46","guid":{"rendered":"https:\/\/ikriv.com\/blog\/?p=4492"},"modified":"2019-03-04T23:53:01","modified_gmt":"2019-03-05T04:53:01","slug":"why-constructors-must-be-simple","status":"publish","type":"post","link":"https:\/\/ikriv.com\/blog\/?p=4492","title":{"rendered":"Why constructors must be simple"},"content":{"rendered":"\n

Recently I’ve got another reminder why constructors should be simple. The situation in a nutshell: class BaseHandler <\/strong>subscribes to an observable in its constructor. The handler is virtual, class DerviedHandler <\/strong>adds incoming items ino a list initialized in its <\/em>constructor. So, there is a potential virtual function call in constructor, but there is also a race condition. If there is nothing in the observable at the time of the construction, everything works. But if there is, virtual function gets called in the constructor, leading to the derived handler to operate on a non-initialized instance, and hilarity ensues.<\/p>\n\n\n\n

Complete code is below, and is also on github<\/a>. If the conditions are right, the exception occurs in DerivedHandler.HandleItem()<\/strong>, because _list<\/strong> is null. What is especially annoying, _list <\/strong>is marked readonly,<\/strong> so we mentally block the idea that it may, in fact, change value over time.<\/p>\n\n\n\n

Yes, C++ has Resource Aquisition is Initialization paradigm, but C++ is a different language. C++ also does not allow virtual function calls in constructors: they blow up. C# does allow virtual function calls in constructors, which is probably fine, but combined with observables this leads to funny results.<\/p>\n\n\n\n

The moral of the story is that we are all better off if constructors do not attempt to do anything fancy. Perform the bare minimum initialization, and then leave the rest to the Start()<\/strong> or Connect() <\/strong>method. Yes, you’ll have to call that method explicitly, but this is a small price to pay for not having to hunt ridiculous race conditions.<\/p>\n\n\n\n

\/\/ Base class, provides virtual HandleItem() method called when new item is observed<\/span>\nclass<\/span> BaseHandler<\/span> : IDisposable<\/span>\n{\n    private<\/span> readonly<\/span> IDisposable<\/span> _subscription;\n\n    public<\/span> BaseHandler(IObservable<\/span><int<\/span>> items)\n    {\n        _subscription = items.Subscribe(HandleItem);\n    }\n\n    public<\/span> void<\/span> Dispose()\n    {\n        _subscription.Dispose();\n    }\n\n    \/\/ default handler for observed item prints the value<\/span>\n    protected<\/span> virtual<\/span> void<\/span> HandleItem(int<\/span> n)\n    {\n        Console<\/span>.WriteLine(n);\n    }\n}\n\n\/\/ Derived class handles observed items by adding them to a list<\/span>\nclass<\/span> DerivedHandler<\/span> : BaseHandler<\/span>\n{\n    private<\/span> readonly<\/span> List<\/span><int<\/span>> _items; \/\/ not initialized here on purpose<\/span>\n\n    public<\/span> DerivedHandler(IObservable<\/span><int<\/span>> items)\n        :\n        base<\/span>(items)\n    {\n        _items = new<\/span> List<\/span><int<\/span>>();\n    }\n\n    protected<\/span> override<\/span> void<\/span> HandleItem(int<\/span> n)\n    {\n        Console<\/span>.WriteLine(\"Adding item: <\/span>{0}<\/span>\"<\/span>, n);\n        _items.Add(n); \/\/ this causes NullReferenceExceptino if called from the base's constructor<\/span>\n    }\n}\n\nclass<\/span> Program<\/span>\n{\n    static<\/span> void<\/span> Main()\n    {\n        using<\/span> (var<\/span> subject = new<\/span> ReplaySubject<\/span><int<\/span>>())\n        {\n            \/\/ Publish an item before constructing any handler objects; this will cause an exception in constructor<\/span>\n            \/\/ Comment this out to prevent the exception<\/span>\n            subject.OnNext(42); \n\n            using<\/span> (new<\/span> DerivedHandler<\/span>(subject))\n            {\n                \/\/ publish a new item to process<\/span>\n                subject.OnNext(43);\n                Console<\/span>.ReadLine();\n            }\n        }\n    }\n}\n\n<\/pre>\n\n\n\n
<\/p>\n","protected":false},"excerpt":{"rendered":"
Recently I’ve got another reminder why constructors should be simple. The situation in a nutshell: class BaseHandler subscribes to an observable in its constructor. The handler is virtual, class DerviedHandler adds incoming […]<\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"Layout":"","footnotes":""},"categories":[3,5],"tags":[],"class_list":["entry","author-ikriv","post-4492","post","type-post","status-publish","format-standard","category-dotnet","category-dev"],"_links":{"self":[{"href":"https:\/\/ikriv.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/4492","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/ikriv.com\/blog\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/ikriv.com\/blog\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/ikriv.com\/blog\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/ikriv.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=4492"}],"version-history":[{"count":1,"href":"https:\/\/ikriv.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/4492\/revisions"}],"predecessor-version":[{"id":4496,"href":"https:\/\/ikriv.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/4492\/revisions\/4496"}],"wp:attachment":[{"href":"https:\/\/ikriv.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=4492"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/ikriv.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=4492"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/ikriv.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=4492"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}