Helper that hold methods for evaluate and calculate data I would like some advice to shorten down this snippet, give it more efficient flow and look. Review should focus on keeping it as a compact single method (except the two public props). The DataType and MeasureStatus is an enum. Readability is of course more important than compactness.

....
/// &lt;summary&gt;
/// Helper that hold methods for evaluate and calculate data 
/// that will be serialized/deserialized in Serializer/SerializerBase.
/// Please don't put serializing routines in here and also understand 
/// that some decisions here are based on protocol specifikations.
/// &lt;/summary&gt;
....
public Unit MeasureType { get; set; }
public ModeType Aggregate { get; set; }
.....

public Tuple&lt;DataType, byte&gt; EvaluateDataType(double value, MeasureStatus? status = null)
{
    int quantityOfDecimals = 0;
    DataType dataType = DataType.MISSING_LONG;
    byte nibbled = 0;
    bool statusIsMissing = false;

    if (status != null)
        if (status == MeasureStatus.Missing)
            statusIsMissing = true;

    quantityOfDecimals = 
      (this.MeasureType == Unit.kWh || this.MeasureType == Unit.ºC) ? 1 : 2;

    // Qty decimals affect limit size  of 'value'
    if (quantityOfDecimals == 1)
    {
        if (value &lt; 3276 &amp;&amp; value &gt; -3276)
            if (!statusIsMissing)
                dataType = DataType.SHORT_1DEC;
            else
                dataType = DataType.MISSING_SHORT;
        else
            if (!statusIsMissing)
                dataType = DataType.LONG_1DEC;
            else
                dataType = DataType.MISSING_LONG;
    }

    // Qty decimals affect limit size  of 'value'
    if (quantityOfDecimals == 2)
    {
        if (value &lt; 327 &amp;&amp; value &gt; -327)
            if (!statusIsMissing)
                dataType = DataType.SHORT_2DEC;
            else
                dataType = DataType.MISSING_SHORT;
        else
            if (!statusIsMissing)
                dataType = DataType.LONG_2DEC;
            else
                dataType = DataType.MISSING_LONG;
    }

    nibbled = (byte)(Aggregate | dataType);
    return new Tuple&lt;DataType, byte&gt;(dataType, nibbled);
}
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...).