C#, How can You make An Object Reinitialize itself?

Question

Ok, in Perl causing an object to reinitialize itself is easy since it is represented by an assignable reference or pointer. C#, however, doesn't appear to like this.

I wanted to create a subclass of System.Text.RegularExpressions.Regex whose pattern could be changed without using new objects and consuming memory for each. (private initialize references wouldn't let me run it again so I tried recreating the object reference).

Is this possible to do without creating a full wrapper around the parent object with re-implementation of every method to point to a private regex object that is reinitialized for each new use? Is there a better way?

public class m_Regex : System.Text.RegularExpressions.Regex{

    public m_Regex(string pattern): base (pattern){

    }

    public void Pattern(string pattern){
        this = new m_Regex(pattern);
    }   
}

Answer 1

Hi Steve

C# does not support such a syntax. In fact if you try compile your code, you'll get a compile error stating that: "this is a read-only property". Unfortunately, no luck for you today. :)

Another way is not to base your class on a Regex but have a wrapper class. For example.

public class Wrapper
{
 private Regex _regex;
 public Wrapper(string pattern)
 {
  _regex = new Regex(pattern);
 }
}

Answer 2

I wonder if there is a good external Regex "competitor" to the built-in .NET one that you could use for this.

Maybe = http://www.codeguru.com/Cpp/Cpp/string/regex/article.php/c2779/

Answer 3

I'm not sure exactly what problem you're trying to solve. If you're concerned about the amount of memory being used, perhaps due to rapid creation/deletion of Regex objects, then you could have your wrapper implement IDisposable and wrap them in a using block so that the resources are freed more rapidly. If the number of Regex objects is fairly small, then I'm not sure that I would worry too much about it. Once the object goes out of scope it can be garbage collected. If the Regex object are fixed, you may also want to think about creating static instances of each in a "regex factory" that you can use over and over.

Answer 4

The reason the System.Text.RegularExpressions.Regex class behaves this way is because it is immutable. Thus, you cannot change the pattern once the Regex object has been created. In short, there is no way to do what you want to do, i.e., re-initialize the existing object with a new pattern. If you want to change the pattern, by definition, you'll have to create a new Regex object.

Answer 5

After some mucking about I found that this does what I want with some (minor) semantic differences

`public class m_Regex : System.Text.RegularExpressions.Regex{

 public m_Regex(string pattern): base (pattern){

 }

 public m_Regex Pattern(string pattern){

  return new m_Regex(pattern);
 }


}`

So now I can use pattern to 'redefine' the current regex by assigning a new object reference to the holding variable instead of replacing the instance itself. And so now (presumably) the previous regex reference is marked for the GC since nobody is using it anymore and the more palatable and self documenting

myregex = myregex.Pattern("^NewPattern$"); can be used giving the functional illusion of pattern changing regex, although I think I still would have preferred to be able to just simply invoke the member and cause it to happen completely behind the scenes.

So am I right? Will GC pickup all the used regexes following this sort of pattern? Will it do so even while the current instantiation is in scope? When does GC happen?

Answer 6

//First use
myregex = new RegEx("^Pattern$");    
// later on in the code, i need to change pattern
// this call is different to the first, and i can't tell why..
myregex = myregex.Pattern("^NewPattern$");

If I were to look at code where this pattern was used, I would immediately jump to the implementation of .Pattern to understand why the 'next' use of myregex was different from the first. My expectation would be that the construction of the new regex was influenced by the state of the current regex instance (I've been trying and failing to how it would be influenced though).

.Pattern has the feel of a factory method, but it's on an instance of itself, which I find confusing and doesn't appear to add any value over the direct use of the RegEx constructor.

Regarding the GC question, the GC can be forced to run with a call to GC.Collect() but it's asking for a collection is an exceptional thing and shouldn't be called as a rule.