기술자의 길, 예술가의 길

"C:\Program Files\Microsoft Visual Studio .NET 2003\Common7\IDE\devenv.exe"

start /D"C:\Program Files\Microsoft Visual Studio .NET 2003\Common7\IDE\" /B devenv.exe

START ["title"] [/Dpath] [/I] [/MIN] [/MAX] [/SEPARATE | /SHARED]
      [/LOW | /NORMAL | /HIGH | /REALTIME | /ABOVENORMAL | /BELOWNORMAL]
      [/WAIT] [/B] [command/program]
      [parameters]

    "title"     Title to display in  window title bar.
    path        Starting directory
    B           Start application without creating a new window. The
                application has ^C handling ignored. Unless the application
                enables ^C processing, ^Break is the only way to interrupt
                the application
    I           The new environment will be the original environment passed
                to the cmd.exe and not the current environment.
    MIN         Start window minimized
    MAX         Start window maximized
    SEPARATE    Start 16-bit Windows program in separate memory space
    SHARED      Start 16-bit Windows program in shared memory space
    LOW         Start application in the IDLE priority class
    NORMAL      Start application in the NORMAL priority class
    HIGH        Start application in the HIGH priority class
    REALTIME    Start application in the REALTIME priority class
    ABOVENORMAL Start application in the ABOVENORMAL priority class
    BELOWNORMAL Start application in the BELOWNORMAL priority class
    WAIT        Start application and wait for it to terminate
    command/program
                If it is an internal cmd command or a batch file then
                the command processor is run with the /K switch to cmd.exe.
                This means that the window will remain after the command
                has been run.

                If it is not an internal cmd command or batch file then
                it is a program and will run as either a windowed application
                or a console application.

    parameters  These are the parameters passed to the command/program


If Command Extensions are enabled, external command invocation
through the command line or the START command changes as follows:

non-executable files may be invoked through their file association just
    by typing the name of the file as a command.  (e.g.  WORD.DOC would
    launch the application associated with the .DOC file extension).
    See the ASSOC and FTYPE commands for how to create these
    associations from within a command script.

When executing an application that is a 32-bit GUI application, CMD.EXE
    does not wait for the application to terminate before returning to
    the command prompt.  This new behavior does NOT occur if executing
    within a command script.

When executing a command line whose first token is the string "CMD "
    without an extension or path qualifier, then "CMD" is replaced with
    the value of the COMSPEC variable.  This prevents picking up CMD.EXE
    from the current directory.

When executing a command line whose first token does NOT contain an
    extension, then CMD.EXE uses the value of the PATHEXT
    environment variable to determine which extensions to look for
    and in what order.  The default value for the PATHEXT variable
    is:

        .COM;.EXE;.BAT;.CMD

    Notice the syntax is the same as the PATH variable, with
    semicolons separating the different elements.

When searching for an executable, if there is no match on any extension,
then looks to see if the name matches a directory name.  If it does, the
START command launches the Explorer on that path.  If done from the
command line, it is the equivalent to doing a CD /D to that path.

start /D"C:\Program Files\Microsoft Visual Studio .NET 2003\Common7\IDE\" /B devenv.exe

start /D"C:\Program Files\Mozilla Firefox" /B firefox.exe
start /D"C:\Program Files\Microsoft Visual Studio .NET 2003\Common7\IDE\" /B devenv.exe
start /D"C:\Program Files\NUnit 2.4.7\bin\" /B nunit.exe
start /D"C:\Program Files\mozilla" /B thunderbird.exe
start /D"C:\Program Files\Microsoft Office\Office12\" /B OUTLOOK.EXE /recycle
start /D"C:\cygwin\" /B Cygwin.bat
start /D"C:\WINNT\" /B explorer.exe "C:\svn\myprojects"

using System;

namespace Chain_of_responsibility
{
    public abstract class Chain
    {
        private Chain _next;

        public Chain Next
        {
            get
            {
                return _next;
            }
            set
            {
                _next = value;
            }
        }

        public void Message(object command)
        {
            if ( Process(command) == false && _next != null )
            {
                _next.Message(command);
            }
        }

        public static Chain operator +(Chain lhs, Chain rhs)
        {
            Chain last = lhs;

            while ( last.Next != null )
            {
                last = last.Next;
            }

            last.Next = rhs;

            return lhs;
        }

        protected abstract bool Process(object command);
    }

    public class StringHandler : Chain
    {
        protected override bool Process(object command)
        {
            if ( command is string )
            {
                Console.WriteLine("StringHandler can handle this message : {0}",(string)command);

                return true;
            }

            return false;
        }
    }

    public class IntegerHandler : Chain
    {
        protected override bool Process(object command)
        {
            if ( command is int )
            {
                Console.WriteLine("IntegerHandler can handle this message : {0}",(int)command);

                return true;
            }

            return false;
        }
    }

    public class NullHandler : Chain
    {
        protected override bool Process(object command)
        {
            if ( command == null )
            {
                Console.WriteLine("NullHandler can handle this message.");

                return true;
            }

            return false;
        }
    }

    public class IntegerBypassHandler : Chain
    {
        protected override bool Process(object command)
        {
            if ( command is int )
            {
                Console.WriteLine("IntegerBypassHandler can handle this message : {0}",(int)command);

                return false; // Always pass to next handler
            }

            return false; // Always pass to next handler
        }
    }

    class TestMain
    {
        static void Main(string[] args)
        {
            Chain chain = new StringHandler();
            chain += new IntegerBypassHandler();
            chain += new IntegerHandler();
            chain += new IntegerHandler(); // Never can reached
            chain += new NullHandler();

            chain.Message("1st string value");
            chain.Message(100);
            chain.Message("2nd string value");
            chain.Message(4.7f); // not handled
            chain.Message(null);
        }
    }
}

using System;
using System.Collections;

namespace Chain_of_responsibility
{
    public interface IChain
    {
        bool Process(object command);
    }

    public class Chain
    {
        private ArrayList _list;

        public ArrayList List
        {
            get
            {
                return _list;
            }
        }

        public Chain()
        {
            _list = new ArrayList();
        }

        public void Message(object command)
        {
            foreach ( IChain item in _list )
            {
                bool result = item.Process(command);

                if ( result == true ) break;
            }
        }

        public void Add(IChain handler)
        {
            List.Add(handler);
        }
    }

    public class StringHandler : IChain
    {
        public bool Process(object command)
        {
            if ( command is string )
            {
                Console.WriteLine("StringHandler can handle this message : {0}",(string)command);

                return true;
            }

            return false;
        }
    }

    public class IntegerHandler : IChain
    {
        public bool Process(object command)
        {
            if ( command is int )
            {
                Console.WriteLine("IntegerHandler can handle this message : {0}",(int)command);

                return true;
            }

            return false;
        }
    }

    public class NullHandler : IChain
    {
        public bool Process(object command)
        {
            if ( command == null )
            {
                Console.WriteLine("NullHandler can handle this message.");

                return true;
            }

            return false;
        }
    }

    public class IntegerBypassHandler : IChain
    {
        public bool Process(object command)
        {
            if ( command is int )
            {
                Console.WriteLine("IntegerBypassHandler can handle this message : {0}",(int)command);

                return false; // Always pass to next handler
            }

            return false; // Always pass to next handler
        }
    }

    class TestMain
    {
        static void Main(string[] args)
        {
            Chain chain = new Chain();

            chain.Add(new StringHandler());
            chain.Add(new IntegerBypassHandler());
            chain.Add(new IntegerHandler());
            chain.Add(new IntegerHandler()); // Never can reached
            chain.Add(new NullHandler());

            chain.Message("1st string value");
            chain.Message(100);
            chain.Message("2nd string value");
            chain.Message(4.7f); // not handled
            chain.Message(null);
        }
    }
}

using System;

namespace Chain_of_responsibility
{
    public class StringHandler
    {
        private static int count;

        public void Process(object command)
        {
            if ( command is string )
            {
                string th;
                count++;

                if ( count % 10 == 1 ) th = "st";
                else if ( count % 10 == 2 ) th = "nd";
                else if ( count % 10 == 3 ) th = "rd";
                else th = "th";

                Console.WriteLine("StringHandler can handle this {0}{1} message : {2}",count,th,(string)command);
            }
        }
    }

    public class StringHandler2
    {
        public void Process(object command)
        {
            if ( command is string )
            {
                Console.WriteLine("StringHandler2 can handle this message : {0}",(string)command);
            }
        }
    }

    public class IntegerHandler
    {
        public void Process(object command)
        {
            if ( command is int )
            {
                Console.WriteLine("IntegerHandler can handle this message : {0}",(int)command);
            }
        }
    }

    class Chain
    {
        public delegate void MessageHandler(object message);
        public static event MessageHandler Message;

        public static void Process(object message)
        {
            Message(message);
        }
    }

    class TestMain
    {
        static void Main(string[] args)
        {
            StringHandler sh1 = new StringHandler();
            StringHandler2 sh2 = new StringHandler2();
            IntegerHandler ih = new IntegerHandler();

            Chain.Message += new Chain.MessageHandler(sh1.Process);
            Chain.Message += new Chain.MessageHandler(sh2.Process);
            Chain.Message += new Chain.MessageHandler(ih.Process);
            Chain.Message += new Chain.MessageHandler(ih.Process); // Can also reached

            Chain.Process("1st string value");
            Chain.Process(100);
            Chain.Process("2nd string value");
            Chain.Process(4.7f); // not handled
        }
    }
}

public Interface IProxy
{
    public int DoSomeWork(int a);
}

public class RealObject : IProxy
{
    public int DoSomeWork(int a)
    {
        Console.WriteLine("Real method");
        return a;
    }
}

public class ProxyObject : IProxy
{
    private RealObject real;

    public ProxyObject()
    {
        real = new RealObject();
    }

    public int DoSomeWork(int a)
    {
        // 메소드 수행 전에 하고 싶은 일?
        Console.WriteLine("Before Invoke");
        // 그리고 실제 메소드를 수행.
        int result = real.DoSomeWork(a);
        // 메소드 수행 후에 하고 싶은 일?
        Console.WriteLine("After Invoke");

        return result; // 리턴값을 조작하고 싶다면 여기서...
   }
}

using System.Runtime.Remoting;
using System.Runtime.Remoting.Activation;
using System.Runtime.Remoting.Proxies;
using System.Runtime.Remoting.Messaging;
using System.Runtime.Remoting.Services;


    class MyProxy : RealProxy
    {
        private MarshalByRefObject target;

        public MyProxy(MarshalByRefObject target, Type serverType)
            : base(serverType)
        {
            this.target = target;
        }

        public override IMessage Invoke(IMessage msg)
        {
            IMessage retMsg = null;

            Console.WriteLine("Some pre-processing...");
            if (msg is IConstructionCallMessage)
            {
                Console.WriteLine("Constructor Interrupted.");

                // 객체 생성 메시지 처리
                IConstructionCallMessage ctorMsg = (IConstructionCallMessage)msg;
                RealProxy proxy = RemotingServices.GetRealProxy(target);
                // 실제 객체를 생성한다.
                proxy.InitializeServerObject(ctorMsg);
                // 객체 생성 결과를 ‘만들어’ 반환한다.
                retMsg = EnterpriseServicesHelper.CreateConstructionReturnMessage
                    (ctorMsg, (MarshalByRefObject) this.GetTransparentProxy());
            }
            else if (msg is IMethodCallMessage)
            {
                IMethodCallMessage callMsg = (IMethodCallMessage)msg;
                if ( callMsg.MethodName == "bar" )
                    Console.WriteLine("Method Interrupted.");

                if ( callMsg.MethodName == "add" )
                {
                    Console.WriteLine("Method Interrupted : add");
                    Console.WriteLine("Parameter list :");

                    for (int i = 0; i < callMsg.ArgCount; i++)
                    {
                        Console.WriteLine("{0} | {1}: {2}", i, callMsg.GetArgName(i), callMsg.GetArg(i));
                    }
                    retMsg = RemotingServices.ExecuteMessage(target, callMsg);
                }
                else
                {
                    retMsg = RemotingServices.ExecuteMessage(target, callMsg);
                }
            }
            Console.WriteLine("Some post-processing...");
            return retMsg;
        }
    }

    [AttributeUsage(AttributeTargets.Class)]
    class MyProxyAttribute : ProxyAttribute
    {
        public override MarshalByRefObject CreateInstance(Type serverType)
        {
            MarshalByRefObject target = base.CreateInstance(serverType);
            MyProxy proxy = new MyProxy(target, serverType);
            MarshalByRefObject obj = (MarshalByRefObject)proxy.GetTransparentProxy();
            return obj;
        }
    }

    [MyProxy]
    class TargetObject : ContextBoundObject
    {
        public TargetObject(string s)
        {
            Console.WriteLine("constructor invoked !!! " + s);
        }
        public void foo()
        {
            Console.WriteLine("foo() invoked !!!");
        }
        public void bar()
        {
            Console.WriteLine("bar() invoked !!!");
        }
        public int add(int a, int b)
        {
            Console.WriteLine("add() invoked !!!");
            return a + b;
        }
    }

    public static void Main()
    {
            TargetObject obj = new TargetObject("test");
            obj.foo();
            obj.bar();

            Console.WriteLine(obj.add(3, 2).ToString());
    }

Some pre-processing...
Constructor Interrupted.
constructor invoked !!! test
Some post-processing...
Some pre-processing...
foo() invoked !!!
Some post-processing...
Some pre-processing...
Method Interrupted.
bar() invoked !!!
Some post-processing...
Some pre-processing...
Method Interrupted : add
Parameter list :
0 | a: 3
1 | b: 2
add() invoked !!!
Some post-processing...
5
계속하려면 아무 키나 누르십시오 . . .