The code has tests, and after applying the refactoring, I have a failing test - which hints that somewhere there's an implicit conversion from the new strongly typed object back to a string. The test's failing assertion says it received "MyNamespace.TypedThing" (which is what the default implementation of
ToString() returns), rather than the wrapped string value that TypedThing encapsulates. My initial suspicion is that there's probably code similar to this that's causing the problem:
TypedThing thing = new TypedThing("thingy");
string s = $"{thing}";ReSharper has a cool utility - "Structural Search and Replace". Unfortunately it doesn't work for single expressions like
"{thing}".If I was cluey, I might be able to write a Roslyn tool to search the code and find instances like that, but that's going to take a bit more effort than I want.
What about this: temporarily override the
ToString() method on my custom type, and make it throw an exception!It's a bit of a sledgehammer, but it worked!
As it turns out my suspicion was not quite correct. The offending code was actually assigning the custom type to an
Object type (which explains the lack of compiler type warnings), which later on must be converted to a string.Now that I could see an example, I could use ReSharper's SSR to confirm that was the only instance of that kind of assignment (SSR can be used as I'm searching for an assignment statement, not just a single expression). Just for good measure, I'll also re-run the entire test suite to make sure there aren't any other similar problems still hiding.
