Helper that hold methods for evaluate and calculate data
There are some (potentially bizarre to me) things going on here.  A slightly larger view of the system may be helpful in further refining this method.  In any case, here's how I'd restructure this.  I've also included notes about some things I found odd...

public Tuple&lt;DataType, byte&gt; EvaluateDataType(double value, MeasureStatus? status = null) 
{ 

    // As much as possible, initialize a local variable to the proper value
    // when you declare it (as if it had Java's *final* attatched).
    // This isn't always possible, of course
    DataType dataType;
    // Really, these are the only two datatypes that use 1 decimal place?
    int decimalPlaces = (MeasureType == Unit.kWh || MeasureType == Unit.ºC) ? 1 : 2;
    // Structure your code so that it's values and executions give the -reasons-
    // or the -why-.  The code itself says -what- is happening, but it's usually -why-
    // that's actually important.  
    // Among other things, this means you should (usually) avoid magic numbers. 
    bool valueOutOfRange = Math.Abs(value) &gt;= (Int16.MaxValue / (10 * decimalPlaces)); 

    // status == null is considered -present-?
    if (status != null &amp;&amp; status == MeasureStatus.Missing) 
    {
    // Note, never leave off brackets - {} - you run a nasty risk of
    // someone writing indented code that isn't actually part of the block.   
    // Also, as much as possible, test for -affirmative- results, not negative ones.
    // Although, multiple negatives should still be avoided.         
        if (valueOutOfRange) 
        {
            dataType = DataType.MISSING_LONG;
        } 
        else
        {
            dataType = DataType.MISSING_SHORT;
        }
    }
    else
    {
        if (valueOutOfRange) 
        {
            if (decimalPlaces == 1) 
            {
                dataType = DataType.LONG_1DEC;
            }
            else
            {
                dataType = DataType.LONG_2DEC;
            }
        }
        else
        {
            if (decimalPlaces == 1)
            {
                dataType = DataType.SHORT_1DEC;
            }
            else 
            }
                dataType = DataType.SHORT_2DEC;
            }
        }
    }

    // Are you sure you don't mean "byte nibbled = (byte) (Aggregate &amp; dataType);"?
    // I'm assuming you're attempting to mask Aggregate for the cast, and that 
    // you haven't done anything -too- out there in the operator override.
    byte nibbled = (byte) (Aggregate | dataType);
    return new Tuple&lt;DataType, byte&gt;(dataType, nibbled);
}


Although, I'm a little suspicious of anything that's moving some sort of DataType around like this (especially because you're only storing a byte).  Normally it's best to prefer some sort of implemented generic, so you can get compile time checking of your datatypes.  Nothing like mismatches at runtime to crash your probe into Mars (granted, that was a mismatch in the measure type, which you're attempting to cover here.  However, you still need to deal with value mis-matches...).