type of和 instance of 差异

化解情势:

typeof: 检查测试变量的项目
instance of :是或不是是哪个人的实例对象

转自:http://www.cnblogs.com/z_lb/archive/2012/09/16/2687487.html

public partial class App : Application

   {

       private static Semaphore singleInstanceWatcher;

       private static bool createdNew;

 

       static App()

       {

           // Ensure other instances of this application are not running.

           singleInstanceWatcher = new Semaphore(

               0, // Initial count.

               1, // Maximum count.

               Assembly.GetExecutingAssembly().GetName().Name,

               out createdNew);

 

           if (createdNew)

           {

               // This thread created the kernel object so no other instance

               // of this application must be running.

               //Application currApp = Application.Current;

               //currApp.StartupUri = new Uri("MainWindow.xaml", UriKind.RelativeOrAbsolute);

               MainWindow win = new MainWindow();

               win.Show();

           }

           else

           {

               // This thread opened an existing kernel object with the same

               // string name; another instance of this app must be running now.

               // Gets a new System.Diagnostics.Process component and the

               // associates it with currently active process.

               Process current = Process.GetCurrentProcess();

 

               // Enumerate through all the process resources on the share

               // local computer that the specified process name.

               foreach (Process process in

                    Process.GetProcessesByName(current.ProcessName))

               {

                   if (process.Id != current.Id)

                   {

                       NativeMethods.SetForegroundWindow(

                           process.MainWindowHandle);

                       NativeMethods.ShowWindow(process.MainWindowHandle,

                           WindowShowStyle.Restore);

                       break;

                   }

               }

 

               // Terminate this process and gives the underlying operating 

               // system the specified exit code.

               Environment.Exit(-2);

           }

 

 // 如果代码在Application_Startup中 如下

       // private Semaphore singleInstanceWatcher;

         // private bool createdNew;

//private void Application_Startup(object sender, StartupEventArgs e)

           //{

           //    singleInstanceWatcher = new Semaphore(

           //   0, // Initial count.

           //   1, // Maximum count.

           //   Assembly.GetExecutingAssembly().GetName().Name,

           //   out createdNew);

           //    if (createdNew)

           //    {

           //        // This thread created the kernel object so no other instance

           //        // of this application must be running.

           //        Application currApp = Application.Current;

           //        currApp.StartupUri = new Uri("MainWindow.xaml", UriKind.RelativeOrAbsolute);

           //    }

           //    else

           //    {

           //        //MessageBox.Show("系统已经运行");

           //        Process current = Process.GetCurrentProcess();

           //        foreach (Process process in

           //             Process.GetProcessesByName(current.ProcessName))

           //        {

           //            if (process.Id != current.Id)

           //            {



           //                NativeMethods.SetForegroundWindow(

           //                    process.MainWindowHandle);

           //                NativeMethods.ShowWindow(process.MainWindowHandle,

           //                    WindowShowStyle.Restore);

           //                break;

           //            }

           //        }

           //        Environment.Exit(-2);

           //    }

}

   }

       internal enum WindowShowStyle : uint

       {

           /// <summary>Hides the window and activates another window.</summary>

           /// <remarks>See SW_HIDE</remarks>

           Hide = 0,

           /// <summary>Activates and displays a window. If the window ..

           /// or maximized, the system restores it to its original size and

           /// position. An application should specify this flag when displaying

           /// the window for the first time.</summary>

           /// <remarks>See SW_SHOWNORMAL</remarks>

           ShowNormal = 1,

           /// <summary>Activates the window and displays it ..</summary>

           /// <remarks>See SW_SHOWMINIMIZED</remarks>

           ShowMinimized = 2,

           /// <summary>Activates the window and displays it ..</summary>

           /// <remarks>See SW_SHOWMAXIMIZED</remarks>

           ShowMaximized = 3,

           /// <summary>Maximizes the specified window.</summary>

           /// <remarks>See SW_MAXIMIZE</remarks>

           Maximize = 3,

           /// <summary>Displays a window in its most recent size and position.

           /// This value is similar to "ShowNormal", except the window is not

           /// actived.</summary>

           /// <remarks>See SW_SHOWNOACTIVATE</remarks>

           ShowNormalNoActivate = 4,

           /// <summary>Activates the window and displays it in its current size

           /// and position.</summary>

           /// <remarks>See SW_SHOW</remarks>

           Show = 5,

           /// <summary>Minimizes the specified window and activates the next

           /// top-level window in the Z order.</summary>

           /// <remarks>See SW_MINIMIZE</remarks>

           Minimize = 6,

           /// <summary>Displays the window as a minimized window. This value is

           /// similar to "ShowMinimized", except the window ..</summary>

           /// <remarks>See SW_SHOWMINNOACTIVE</remarks>

           ShowMinNoActivate = 7,

           /// <summary>Displays the window in its current size and position. This

           /// value is similar to "Show", except the window ..</summary>

           /// <remarks>See SW_SHOWNA</remarks>

           ShowNoActivate = 8,

           /// <summary>Activates and displays the window. If the window is

           /// minimized or maximized, the system restores it to its original size

           /// and position. An application should specify this flag ..

           /// a minimized window.</summary>

           /// <remarks>See SW_RESTORE</remarks>

           Restore = 9,

           /// <summary>Sets the show state based on the SW_ value specified ..

           /// STARTUPINFO structure passed to the CreateProcess function by the

           /// program that started the application.</summary>

           /// <remarks>See SW_SHOWDEFAULT</remarks>

           ShowDefault = 10,

           /// <summary>Windows 2000/XP: Minimizes a window, even if the thread

           /// that owns the window is hung. This flag should only be used when

           /// minimizing windows from a different thread.</summary>

           /// <remarks>See SW_FORCEMINIMIZE</remarks>

           ForceMinimized = 11

       }

       static class NativeMethods

       {

           /// <summary>

           /// Brings the thread that created the specified window into the

           /// foreground and activates the window. Keyboard input is directed

           /// to the window, and various visual cues are changed for the user.

           /// The system assigns a slightly higher priority to the thread that

           /// created the foreground window than it does to other threads.

           /// </summary>

           /// <param name="hWnd">A handle to the window that should be

           /// activated and brought to the foreground.

           /// </param>

           /// <returns>If the window was brought to the foreground, the

           /// return value is nonzero. </returns>

           [DllImport("user32.dll")]

           internal static extern bool SetForegroundWindow(IntPtr hWnd);

 

           /// <summary>Shows a Window</summary>

           /// <remarks>

           /// <para>To perform certain special effects when showing or hiding a

           /// window, use AnimateWindow.</para>

           /// <para>The first time an application calls ShowWindow, it should use

           /// the WinMain function's nCmdShow parameter as its nCmdShow ..

           /// Subsequent calls to ShowWindow must use one of the values in the

           /// given list, instead of the one specified by the WinMain function's

           /// nCmdShow parameter.</para>

           /// <para>As noted in the discussion of the nCmdShow parameter, the

           /// nCmdShow value is ignored in the first call to ShowWindow if the

           /// program that launched the application specifies startup information

           /// in the structure. In this case, ShowWindow uses the information

           /// specified in the STARTUPINFO structure to show the window. On

           /// subsequent calls, the application must call ShowWindow with ..

           /// set to SW_SHOWDEFAULT to use the startup information provided by ..

           /// program that launched the application. This behavior is designed ..

           /// the following situations: </para>

           /// <list type="">

           ///    <item>Applications create their main window by calling ..

           ///    with the WS_VISIBLE flag set. </item>

           ///    <item>Applications create their main window by calling ..

           ///    with the WS_VISIBLE flag cleared, and later call ShowWindow ..

           ///    SW_SHOW flag set to make it visible.</item>

           /// </list></remarks>

           /// <param name="hWnd">Handle to the window.</param>

           /// <param name="nCmdShow">Specifies how the window is to be shown.

           /// This parameter is ignored the first time an application calls

           /// ShowWindow, if the program that launched the application provides a

           /// STARTUPINFO structure. Otherwise, the first time ShowWindow .. ,

           /// the value should be the value obtained by the WinMain function ..

           /// nCmdShow parameter. In subsequent calls, this parameter ..

           /// the WindowShowStyle members.</param>

           /// <returns>

           /// If the window was previously visible, the return value is nonzero.

           /// If the window was previously hidden, the return value is zero.

           /// </returns>

           [DllImport("user32.dll")]

           internal static extern bool ShowWindow(IntPtr hWnd,

               WindowShowStyle nCmdShow);

       }
JavaScript 中 typeof 和 instanceof 常用来判别3个变量是不是为空,可能是怎么着品种的。但它们中间或许有分其余:
  1. typeof
    typeof 是2个一元运算,放在2个运算数在此之前,运算数能够是即兴档期的顺序。
    它重回值是二个字符串,该字符串表达运算数的品类。typeof
    一般只可以回去如下多少个结实:
    number,boolean,string,function,object,undefined。大家能够应用 typeof
    来获得3个变量是还是不是留存,如 if(typeof
    a!=”undefined”){alert(“ok”)},而不要去选拔 if(a) 因为只要 a
    不设有(未申明)则会出错,对于 Array,Null 等非凡对象使用 typeof
    壹律再次来到 object,这就是 typeof 的局限性。
  2. instanceof
    instance:实例,例子
    a instanceof b?alert(“true”):alert(“false”); //a是b的实例?真:假
    instanceof 用于判别三个变量是或不是有个别对象的实例,如 var a=new
    Array();alert(a instanceof Array);
    会回来 true,同时 alert(a instanceof Object) 也会回来 true;那是因为
    Array 是 object
    的子类。再如:function test(){};var a=new test();alert(a instanceof
    test) 会返回
    谈起 instanceof 我们要多插入三个主题素材,正是 function 的
    arguments,咱们大家大概都认为 arguments 是八个
    Array,但假诺利用 instaceof 去测试会意识 arguments 不是1个 Array
    对象,尽管看起来很像。
    另外:
    测试 var a=new Array();if (a instanceof Object) alert(‘Y’);else
    alert(‘N’);
    得’Y’
    但 if (window instanceof Object) alert(‘Y’);else alert(‘N’);
    得’N’
    由此,这里的 instanceof 测试的 object 是指 js 语法中的
    object,不是指 dom 模型对象。
    应用 typeof 会有个别不相同
    alert(typeof(window)) 会得 object

settings中的debug改为false,或然注释掉

澳门新萄京,function Array() {

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图