C#

namespace PIEBALD.Lib.LibExt.Convert
{
    public interface IConvert
    {
        double Convert ( double Value ) ;
    }

    public enum Language
    {
        CSharp
    ,
        VisualBasic
    }

    [System.AttributeUsageAttribute(System.AttributeTargets.Field , AllowMultiple=false , Inherited=false)]
    public sealed class ConverterAttribute : System.Attribute
    {
        public ConverterAttribute
        (
            string   Function
        ,
            Language Language
        )
        {
            this.Function = Function ;

            this.Language = Language ;

            return ;
        }

        public string Function { get ; private set ; }

        public Language Language { get ; private set ; }
    }

    public enum Conversion
    {
        [ConverterAttribute("Value * 2.54",Language.VisualBasic)]
        FromInchToCentimeter
    ,
        [ConverterAttribute("Value / 2.54",Language.VisualBasic)]
        FromCentimeterToInch
    ,
        [ConverterAttribute("( Value - 32.0 ) * 5.0 / 9.0",Language.CSharp)]
        FromFahrenheitToCelsius
    ,
        [ConverterAttribute("Value * 9.0 / 5.0 + 32.0",Language.CSharp)]
        FromCelsiusToFahrenheit
    }

    public static class LibExt
    {
        private static readonly System.Collections.Generic.Dictionary<Conversion,IConvert> conversion ;

        static LibExt
        (
        )
        {
            conversion = new System.Collections.Generic.Dictionary<Conversion,IConvert>() ;

            return ;
        }

        private static void
        Add
        (
            Conversion Conversion
        )
        {
            System.Reflection.FieldInfo fi = typeof(Conversion).GetField
            (
                Conversion.ToString()
            ,
                System.Reflection.BindingFlags.Public
                |
                System.Reflection.BindingFlags.Static
            ) ;

            foreach
            (
                ConverterAttribute att
            in
                fi.GetCustomAttributes ( typeof(ConverterAttribute) , false ) 
            )
            {
                string code = null ;

                switch ( att.Language )
                {
                    case Language.CSharp :
                    {
                        code = System.String.Format
                        (
                            @"
                            namespace Converter
                            {{
                                public class Converter : PIEBALD.Lib.LibExt.Convert.IConvert
                                {{
                                    public double
                                    Convert
                                    (
                                        double Value
                                    )
                                    {{
                                        return ( {0} ) ;
                                    }}
                                }}
                            }}
                            "
                        ,
                            att.Function
                        ) ;

                        break ;
                    }

                    case Language.VisualBasic :
                    {
                        code = System.String.Format
                        (
                            @"
                            namespace Converter
                                public class Converter
                                    implements PIEBALD.Lib.LibExt.Convert.IConvert

                                    public function Convert ( byval Value as double ) as double _
                                        implements PIEBALD.Lib.LibExt.Convert.IConvert.Convert

                                        return ( {0} ) 
                                    end function
                                end class
                            end namespace
                            "
                        ,
                            att.Function
                        ) ;

                        break ;
                    }
                }

                System.Reflection.Assembly assm = PIEBALD.Lib.LibSys.Compile
                (
                    code
                ,
                    att.Language.ToString()
                ,
                    System.Reflection.Assembly.GetExecutingAssembly().Location
                ) ;

                conversion [ (Conversion) fi.GetValue ( null ) ] =
                    (IConvert) assm.CreateInstance ( "Converter.Converter" ) ;
            }

            return ;
        }

        public static double
        Convert
        (
            this double Value
        ,
            Conversion  Conversion
        )
        {
            if ( !conversion.ContainsKey ( Conversion ) )
            {
                Add ( Conversion ) ;
            }

            return ( conversion [ Conversion ].Convert ( Value ) ) ;
        }
    }
}

if(!isSystemCriticalProcess && userUnderWhichYourAppRunsHasRights){
showProcess = true;
canKill = true;
}

d@nish wrote:

if(!isSystemCriticalProcess && userUnderWhichYourAppRunsHasRights){
showProcess = true;
canKill = true;
}

Rajesh R Subramanian wrote:

there is NO process that will NOT be listed in task manager

Pete O'Hanlon wrote:

Rootkits do this quite successfully.

Pete O'Hanlon wrote:

Perhaps it's more accurate to say there is no kernel level process that will not be listed.

Rajesh R Subramanian wrote:

NO process can hide itself from being listed in task manager, with no regards to
whether or not it is run at the kernel level.

Pete O'Hanlon wrote:

But that's exactly what a rootkit can do.

Pete O'Hanlon wrote:

Basically, it can intercept a call to list processes, and return a list of all processes other than itself.

Pete O'Hanlon wrote:

Task manager is a poor application to use to detect these things.