지쏘니의 세상

 // This code example demonstrates the ToString(String) and
// ToString(String, IFormatProvider) methods for integral and
// floating-point numbers, in conjunction with the standard
// numeric format specifiers.
// This code example uses the System.Int32 integral type and
// the System.Double floating-point type, but would yield
// similar results for any of the numeric types. The integral
// numeric types are System.Byte, SByte, Int16, Int32, Int64,
// UInt16, UInt32, and UInt64. The floating-point numeric types
// are Decimal, Single, and Double.

using System;
using System.Globalization;
using System.Threading;

class Sample
{
    public static void Main()
    {
// Format a negative integer or floating-point number in various ways.
    int    integralVal = -12345;
    double floatingVal = -1234.567d;

    string msgCurrency =    "(C) Currency: . . . . . . ";
    string msgDecimal  =    "(D) Decimal:. . . . . . . ";
    string msgScientific =  "(E) Scientific: . . . . . ";
    string msgFixedPoint =  "(F) Fixed point:. . . . . ";
    string msgGeneral =     "(G) General (default):. . ";
    string msgNumber =      "(N) Number: . . . . . . . ";
    string msgPercent =     "(P) Percent:. . . . . . . ";
    string msgRoundTrip =   "(R) Round-trip: . . . . . ";
    string msgHexadecimal = "(X) Hexadecimal:. . . . . ";

    string msg1 = "Use ToString(String) and the current thread culture.\n";
    string msg2 = "Use ToString(String, IFormatProvider) and a specified culture.\n";
    string msgCulture     = "Culture:";
    string msgIntegralVal = "Integral value:";
    string msgFloatingVal = "Floating-point value:";

    CultureInfo ci;
//
    Console.Clear();
    Console.WriteLine("Standard Numeric Format Specifiers:\n");
// Display the values.
    Console.WriteLine(msg1);

// Display the thread current culture, which is used to format the values.
    ci = Thread.CurrentThread.CurrentCulture;
    Console.WriteLine("{0,-26}{1}", msgCulture, ci.DisplayName);

// Display the integral and floating-point values.
    Console.WriteLine("{0,-26}{1}", msgIntegralVal, integralVal);
    Console.WriteLine("{0,-26}{1}", msgFloatingVal, floatingVal);
    Console.WriteLine();

// Use the format specifiers that are only for integral types.
    Console.WriteLine("Format specifiers only for integral types:");
    Console.WriteLine(msgDecimal     + integralVal.ToString("D"));
    Console.WriteLine(msgHexadecimal + integralVal.ToString("X"));
    Console.WriteLine();

// Use the format specifier that is only for the Single and Double
// floating-point types.
    Console.WriteLine("Format specifier only for the Single and Double types:");
    Console.WriteLine(msgRoundTrip   + floatingVal.ToString("R"));
    Console.WriteLine();

// Use the format specifiers that are for integral or floating-point types.
    Console.WriteLine("Format specifiers for integral or floating-point types:");
    Console.WriteLine(msgCurrency    + floatingVal.ToString("C"));
    Console.WriteLine(msgScientific  + floatingVal.ToString("E"));
    Console.WriteLine(msgFixedPoint  + floatingVal.ToString("F"));
    Console.WriteLine(msgGeneral     + floatingVal.ToString("G"));
    Console.WriteLine(msgNumber      + floatingVal.ToString("N"));
    Console.WriteLine(msgPercent     + floatingVal.ToString("P"));
    Console.WriteLine();

// Display the same values using a CultureInfo object. The CultureInfo class
// implements IFormatProvider.
    Console.WriteLine(msg2);

// Display the culture used to format the values.
// Create a European culture and change its currency symbol to "euro" because
// this particular code example uses a thread current UI culture that cannot
// display the euro symbol (€).
    ci = new CultureInfo("de-DE");
    ci.NumberFormat.CurrencySymbol = "euro";
    Console.WriteLine("{0,-26}{1}", msgCulture, ci.DisplayName);

// Display the integral and floating-point values.
    Console.WriteLine("{0,-26}{1}", msgIntegralVal, integralVal);
    Console.WriteLine("{0,-26}{1}", msgFloatingVal, floatingVal);
    Console.WriteLine();

// Use the format specifiers that are only for integral types.
    Console.WriteLine("Format specifiers only for integral types:");
    Console.WriteLine(msgDecimal     + integralVal.ToString("D", ci));
    Console.WriteLine(msgHexadecimal + integralVal.ToString("X", ci));
    Console.WriteLine();

// Use the format specifier that is only for the Single and Double
// floating-point types.
    Console.WriteLine("Format specifier only for the Single and Double types:");
    Console.WriteLine(msgRoundTrip   + floatingVal.ToString("R", ci));
    Console.WriteLine();

// Use the format specifiers that are for integral or floating-point types.
    Console.WriteLine("Format specifiers for integral or floating-point types:");
    Console.WriteLine(msgCurrency    + floatingVal.ToString("C", ci));
    Console.WriteLine(msgScientific  + floatingVal.ToString("E", ci));
    Console.WriteLine(msgFixedPoint  + floatingVal.ToString("F", ci));
    Console.WriteLine(msgGeneral     + floatingVal.ToString("G", ci));
    Console.WriteLine(msgNumber      + floatingVal.ToString("N", ci));
    Console.WriteLine(msgPercent     + floatingVal.ToString("P", ci));
    Console.WriteLine();
    }
}
/*
This code example produces the following results:

Standard Numeric Format Specifiers:

Use ToString(String) and the current thread culture.

Culture:                  English (United States)
Integral value:           -12345
Floating-point value:     -1234.567

Format specifiers only for integral types:
(D) Decimal:. . . . . . . -12345
(X) Hexadecimal:. . . . . FFFFCFC7

Format specifier only for the Single and Double types:
(R) Round-trip: . . . . . -1234.567

Format specifiers for integral or floating-point types:
(C) Currency: . . . . . . ($1,234.57)
(E) Scientific: . . . . . -1.234567E+003
(F) Fixed point:. . . . . -1234.57
(G) General (default):. . -1234.567
(N) Number: . . . . . . . -1,234.57
(P) Percent:. . . . . . . -123,456.70 %

Use ToString(String, IFormatProvider) and a specified culture.

Culture:                  German (Germany)
Integral value:           -12345
Floating-point value:     -1234.567

Format specifiers only for integral types:
(D) Decimal:. . . . . . . -12345
(X) Hexadecimal:. . . . . FFFFCFC7

Format specifier only for the Single and Double types:
(R) Round-trip: . . . . . -1234,567

Format specifiers for integral or floating-point types:
(C) Currency: . . . . . . -1.234,57 euro
(E) Scientific: . . . . . -1,234567E+003
(F) Fixed point:. . . . . -1234,57
(G) General (default):. . -1234,567
(N) Number: . . . . . . . -1.234,57
(P) Percent:. . . . . . . -123.456,70%

*/

           static string providerName = "cs";
        static string sourceFileName = "test.cs";

        /// <summary>
        /// 클래스 생성 및 컴파일
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button1_Click(object sender, EventArgs e)
        {
            CodeDomProvider provider = CodeDomProvider.CreateProvider(providerName);
         
            CodeCompileUnit cu = new CodeCompileUnit();
            cu = BuildHelloWorldGraph();

            StreamWriter sourceFile = new StreamWriter(sourceFileName);
            provider.GenerateCodeFromCompileUnit(cu, sourceFile, null);
            sourceFile.Close();

            CompilerParameters opt = new CompilerParameters(new string[] { "System.dll" });
            opt.GenerateExecutable = true;
            opt.OutputAssembly = "HelloWorld.exe";
            opt.TreatWarningsAsErrors = true;
            opt.IncludeDebugInformation = true;
            opt.GenerateInMemory = true;
            opt.CompilerOptions = "/doc:HelloWorldDoc.xml";

            CompilerResults results;
            results = provider.CompileAssemblyFromFile(opt, sourceFileName);
        }

        /// <summary>
        /// 코드컴파일유닛 : 그래프를 생성하징
        /// </summary>
        /// <returns></returns>
        public static CodeCompileUnit BuildHelloWorldGraph()
        {
            // Create a new CodeCompileUnit to contain the program graph.
            CodeCompileUnit compileUnit = new CodeCompileUnit();

            // Declare a new namespace called Samples.
            CodeNamespace samples = new CodeNamespace("Samples");
            // Add the new namespace to the compile unit.
            compileUnit.Namespaces.Add(samples);
            // Add the new namespace import for the System namespace.
            samples.Imports.Add(new CodeNamespaceImport("System"));

            #region 클래스 주석부분 선언하기

            // Declare a new type called Class1.
            CodeTypeDeclaration class1 = new CodeTypeDeclaration("Class1");
            class1.Comments.Add(new CodeCommentStatement("<summary>", true));
            class1.Comments.Add(new CodeCommentStatement("Create a Hello World application.", true));
            class1.Comments.Add(new CodeCommentStatement(@"<seealso cref=" + '"' + "Class1.Main" + '"' + "/>", true));
            class1.Comments.Add(new CodeCommentStatement("</summary>", true));
            // Add the new type to the namespace type collection.
            samples.Types.Add(class1);

            // Declare a new code entry point method.
            CodeEntryPointMethod start = new CodeEntryPointMethod();
            start.Comments.Add(new CodeCommentStatement("<summary>", true));
            start.Comments.Add(new CodeCommentStatement("Main method for HelloWorld application.", true));
            start.Comments.Add(new CodeCommentStatement(@"<para>Add a new paragraph to the description.</para>", true));
            start.Comments.Add(new CodeCommentStatement("</summary>", true));

            #endregion

            // Create a type reference for the System.Console class.
            CodeTypeReferenceExpression csSystemConsoleType = new CodeTypeReferenceExpression("System.Console");

            // CodeMethodInvokeExpression.CodeMethodInvokeExpression(CodeExpression targetObject, string methodName, params CodeExpression[] parameters)
            // Build a Console.WriteLine statement.
            CodeMethodInvokeExpression cs1 = new CodeMethodInvokeExpression(csSystemConsoleType, "WriteLine",
                new CodePrimitiveExpression("Hello World!"));

            // Add the WriteLine call to the statement collection.
            start.Statements.Add(cs1);

            // Build another Console.WriteLine statement.
            CodeMethodInvokeExpression cs2 = new CodeMethodInvokeExpression(csSystemConsoleType, "WriteLine",
                new CodePrimitiveExpression("Press the ENTER key to continue."));

            // Add the WriteLine call to the statement collection.
            start.Statements.Add(cs2);

            // Build a call to System.Console.ReadLine.
            CodeMethodInvokeExpression csReadLine = new CodeMethodInvokeExpression(csSystemConsoleType, "ReadLine");

            // Add the ReadLine statement.
            start.Statements.Add(csReadLine);
            // Add the code entry point method to the Members collection of the type.
            class1.Members.Add(start);

            return compileUnit;
        }