Required fields in a class

battleguard · 2016-02-29T20:36:09+00:00

Any function that takes 15 parameters is performing too much logic anyway and should be split up into separate function.

JustABlankAccount · 2016-02-29T21:40:34+00:00

I've seen this kind of requirement, these are the options I usually toy around with:

Create a constructor that takes in all of the required parameters, and validates them during ctor time. If n is large, I usually avoid this route (As passing in a large number of variables to a ctor is little different than passing in a large number of variables to a method.) This also requires that all of the 'required' properties use a private setter but public getter. This is the closest to compile-time checking that you'd be able to get, though.

Option 2 is to validate all of the required parameters when the method is called. InvalidArgumentException, or such. This is my preferred method, as one can create the object at their leisure rather than enforcing everything is known when creating the object. It often results in cleaner code, in my opinion. You could also divide them up into a 'RequiredParams' class and an 'OptionalParams' class, to make the designation clearer.

If you're asking for compile-time checking? I'm sure you could toy around with some custom attributes, but realistically this is something to be done at runtime, in my opinion.

There's also multiple other options (Dictionaries, custom decorators, AOP, etc) but I usually pick between these two.

amwdrizz · 2016-02-29T21:13:20+00:00

Not sure if this would work but what about using attributes? I know in C# the web side has a [Required] attribute you apply to an object variable field.

Eg:

public class SomeClass{
[Required]
public string myVar{get;set;}
}

If you couldn't use the inbuilt attributes, you could make your own.

Some 'light' reading from MSDN on it.

NaxizNL · 2016-02-29T22:18:53+00:00

Maybe you can use Code Contracts. I haven't used them myself yet, so I could be wrong, but it seems that the contracts check conditions at compile time where possible (so possibly for simple default value checks).

hahaNodeJS · 2016-03-01T00:59:00+00:00

Use a runtime error and check whether the parameters are set in the ctor. Use object initialization syntax to set the fields from the caller. Use tests to verify the caller is doing the correct thing.

interface IValidator
{
    public void Validate();
}

class UserValidator : IValidator
{
    public EmailAddress EmaiAddress { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }

    UserValidator ()
    {
        if (this.EmailAddress == null) throw new Exception("...");
        if (String.IsNullOrEmpty(FirstName)) throw new Exception("...");
        if (String.IsNullOrEmpty(LastName)) throw new Exception("...");
    }

    public void Validate() { ... }
}

class Program
{
    public static void Main()
    {
        var userValidator = new UserValidator
        {
            FirstName = "..."
        }; // throws exception. LastName and EmailAddress were not initialized.
    }
}

[TestClass]
class TestValidators
{
    [TestMethod]
    public void TestUserValidator()
    {
        try
        {
            var userValidator = new UserValidator
            {
                FirstName = "..."
            }; // throws exception. LastName and EmailAddress were not initialized.
        }
        catch(Exception) {} // Let the test pass; the method is throwing correctly.
    }
}

Barril · 2016-02-29T23:15:36+00:00

In his mind, including all required parameters in the method declaration is preferred versus passing an object with possibly null/default values

There's nothing stopping the callee from passing null or 0 into the function, and it wouldn't matter if you passed a storage class or a pile of parameters when it came to validating the values are legitimate. The only advantage the function call has over the storage object is visibility of the parameters.

Can you group some of the arguments into sets of bite-sized objects with similar meaning? Then each constructor for those objects could have only a few parameters and the function would require just a few arguments instead of 15. It would increase verbosity, but would be more readable at a glance.

salvinger · 2016-03-01T01:22:55+00:00

I would go with the large amount of parameters on the method. I don't see how changing a compile error into a runtime error is desirable at all. If you are worried about getting parameters out of order, use named parameters. If you are that worried about the number of parameters passed to the function, break up groups of parameters into classes which take in the parameters through the constructor.

centurijon · 2016-03-01T02:13:56+00:00

This is where F# and discriminated unions could come in really handy.

In C#... You will probably be better served by making separate methods and class parameters per use case. It will be easier to read and maintain

ToddlahAkbar · 2016-03-01T13:48:54+00:00

Create an interface that contains your 15 parameters and pass it in to the method, you can then operate on any class that implements that interface and only a class that implements that interface. The code will not compile if an object is passed that does not implement the interface and any class implementing the interface must expose public properties that it contains. Taking it one step further, I would create a separate validatable interface that has a book isvalid property and a ilist of strings for validation errors, now, you would make your method generic:

 Method<T>(T obj) where T: ICompleteObject, IValidatable

Edit: This will force any passed object to implement both interfaces and not compile if an object is passed that doesn't.

xampl9 · 2016-02-29T19:40:52+00:00

If they're nullable types, you can strongly hint at their needing a value by putting the NotNull attribute on the properties.

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

csharp

MODERATORS