Question

I have various classes for handling form data and querying a database. I need some advice on reducing the amount of code I write from site to site.

The following code is for handling a form posted via ajax to the server. It simply instantiates a Form class, validates the data and processes any errors:

public static string submit(Dictionary<string, string> d){

    Form f = new Form("myform");

    if (!f.validate(d)){

        return f.errors.toJSON();

    }

    //process form...

}

Is there a way to reduce this down to 1 line as follows:

if (!Form.validate("myform", d)){ return Form.errors.toJSON(); }

Answer 1

Let’s break that down into two questions.

1) Can I write the existing logic all in one statement?

The local variable has to be declared in its own statement, but the initializer doesn’t have to be there. It’s prefectly legal to say:

Form f; 
if (!(f=new Form("myform")).validate(d))return f.errors.toJSON(); 

Why you would want to is beyond me; doing so is ugly, hard to debug, hard to understand, and hard to maintain. But it’s perfectly legal.

2) Can I make this instance method into a static method?

Probably not directly. Suppose you had two callers validating stuff on two different threads, both calling the static Form.Validate method, and both producing errors. Now you have a race. One of them is going to win and fill in Form.Errors. And now you have two threads reporting the same set of errors, but the errors are wrong for one of them.

The better way to make this into a static method is to make the whole thing into a static method that has the desired semantics, as in plinth’s answer.

Errors errors = Validator.Validate(d);
if (errors != null) return errors.toJSON();

Now the code is very clear, and the implementation of Validate is straightforward. Create a form, call the validator, either return null or the errors.

I would suggest that you don’t need advice on reducing the amount of code you write. Rather, get advice on how to make the code read more like the meaning it intends to represent. Sometimes that means writing slightly more code, but that code is clear and easy to understand.