C#

PIEBALDconsult wrote:

Don't delete your posts!

Pete O'Hanlon wrote:

the regex for this is:

^(\d*(0){4})

List<string> myList = new List<string>();
myList.AddRange(File.ReadAllLines(path));

// Read from file
string path = @"F:\Temp\roman.txt";
List<string> myList = new List<string>();
myList.AddRange(File.ReadAllLines(path));
// Write to serialization file.
using (Stream stream = File.Open(@"F:\Temp\data.bin", FileMode.Create))
    {
    BinaryFormatter bin = new BinaryFormatter();
    bin.Serialize(stream, myList);
    }
// Read from serialization file
List<string> myList2;
using (Stream stream = File.Open(@"F:\Temp\data.bin", FileMode.Open))
    {
    BinaryFormatter bin = new BinaryFormatter();
    myList2 = (List<string>) bin.Deserialize(stream);
    }

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 ) ) ;
        }
    }
}