Usa struct oppure no

Ho creato un piccolo wrapper per le affermazioni di precondizione fluenti in c #.

Ora fondamentalmente in tutti i metodi pubblici / contrattuali asserisco i valori in questo modo:

Precondition
            .For(()=>Model)
            .NotNull();

Precondition crea un'Istanza ValidationRule su cui dispongo dei metodi di convalida specificati.

Ora questo accade molto spesso e penso che usare una struct potrebbe essere un vantaggio, anche perché ValidationRule ha solo valori, non ci sarà affatto boxing, è sigillato per definizione ed è immutabile. Inoltre, non vengono utilizzati come parametri o eventi al di fuori dell'ambito dei metodi di chiamata.

Ma il contrario è che ha più valori e lì non per quel piccolo ingombro.

Il ValidationRule ha un aspetto sostanzialmente simile a questo:

 public sealed class ValidationRule<T>
    {
        public T Value { get; }

        public string Name { get; }

        public string File { get; }

        public string Source { get; }

        public int Line { get; }

        public ValidationRule(T value, string name, string file, string source, int line)
        {
            Value = value;
            Name = name;
            File = file;
            Source = source;
            Line = line;
        }

        public ValidationRule<T> NotNull()
        {
            if (Value == null)
            {
                throw new ArgumentNullException(Name, "Value must not be null!");
            }
            return this;
        }

        public ValidationRule<T> NotDefault()
        {
            T val = default(T);
            if (Value.Equals(val))
            {
                throw new ArgumentException(Name, "Value must have default value!");
            }
            return this;
        }

Quindi strutturare o no? E il più importante perché?