fNbt.Serialization.Compiled.NbtCompiler.MakeNullHandler C# (CSharp) Method

        internal static Expression MakeNullHandler([NotNull] ParameterExpression varValue,
                                                   [NotNull] Expression getPropertyExpr,
                                                   NullPolicy policy, [NotNull] Expression nonNullExpr,
                                                   [NotNull] Expression defaultValExpr,
                                                   [NotNull] string exceptionMessage) {
            // locate the getter for this property
            Expression ifExpr;

            switch (policy) {
                case NullPolicy.Error:
                    ifExpr = Expression.IfThenElse(
                        // if (value==null) throw new NullReferenceException(exceptionMessage)
                        Expression.ReferenceEqual(varValue, Expression.Constant(null)),
                        Expression.Throw(
                            Expression.New(NullReferenceExceptionCtor, Expression.Constant(exceptionMessage))),
                        // else <nonNullExpr>
                        nonNullExpr);
                    break;
                case NullPolicy.Ignore:
                    ifExpr = Expression.IfThen(
                        // if (value!=null) <nonNullExpr>
                        Expression.Not(Expression.ReferenceEqual(varValue, Expression.Constant(null))),
                        nonNullExpr);
                    break;
                case NullPolicy.InsertDefault:
                    ifExpr = Expression.IfThenElse(
                        // if (value==null) <defaultValExpr>
                        Expression.ReferenceEqual(varValue, Expression.Constant(null)),
                        defaultValExpr,
                        // else <nonNullExpr>
                        nonNullExpr);
                    break;
                default:
                    throw new ArgumentOutOfRangeException("Unrecognized value for NullPolicy: " + policy);
            }

            return Expression.Block(
                // var varValue = value.ThisProperty;
                new[] { varValue },
                Expression.Assign(varValue, getPropertyExpr),
                // (check if value is null, and do something)
                ifExpr);
        }

        // Generates an expression that creates an NbtTag for given property of a directly-mappable types.
        // Directly-mappable types are: primitives, enums, byte[], int[], and string.
        // HandlePrimitiveOrEnum is actually more efficient (and preferred by NbtCompiler) for primitives and enums,
        // because it skips boxing and NullPolicy checks. This one is pretty much only used for byte[]/int[]/string.
        public override Expression HandleDirectlyMappedType(string tagName, PropertyInfo property, NullPolicy selfPolicy)
        {
            // declare a local var, which will hold the property's value
            ParameterExpression varValue = Expression.Parameter(property.PropertyType);

            // Fallback path, in case value is null and NullPolicy is InsertDefaults
            Expression defaultVal = Expression.Constant(SerializationUtil.GetDefaultValue(property.PropertyType));
            // varRootTag.Add( new NbtTag(tagName, <defaultVal>) );
            Expression defaultValExpr =
                Expression.Call(varRootTag,
                                NbtCompoundAddMethod,
                                MakeNbtTagCtor(property.PropertyType,
                                               Expression.Constant(tagName, typeof(string)),
                                               defaultVal));

            // varRootTag.Add( new NbtTag(tagName, <varValue>) );
            Expression makeTagExpr =
                Expression.Call(varRootTag,
                                NbtCompoundAddMethod,
                                MakeNbtTagCtor(property.PropertyType,
                                               Expression.Constant(tagName, typeof(string)),
                                               varValue));

            // Getter for the property value
            Expression getPropertyExpr = Expression.MakeMemberAccess(argValue, property);

            // generate the appropriate enclosing expressions, depending on NullPolicy
            return(NbtCompiler.MakeNullHandler(varValue, getPropertyExpr, selfPolicy,
                                               makeTagExpr, defaultValExpr, MakePropertyNullMessage(property)));
        }