GetWinFXPath.cs source code in C# .NET

                        Code:
                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / wpf / src / BuildTasks / Microsoft / Build / Tasks / Windows / GetWinFXPath.cs / 1305600 / GetWinFXPath.cs
                        
                        
                            //----------------------------------------------------------------------------
//
// 
//    Copyright (C) Microsoft Corporation.  All rights reserved. 
// 
// 
// Description: Return the path for current WinFX runtime. 
//
// 
// History:
//  11/16/2005 weibz   Created
//
//--------------------------------------------------------------------------- 

using System; 
using System.IO; 
using System.Collections;
 
using System.Globalization;
using System.Diagnostics;
using System.Reflection;
using System.Resources; 
using System.Runtime.InteropServices;
 
 
using Microsoft.Build.Framework;
using Microsoft.Build.Utilities; 

using MS.Utility;
using MS.Internal.Tasks;
 
// Since we disable PreSharp warnings in this file, PreSharp warning is unknown to C# compiler.
// We first need to disable warnings about unknown message numbers and unknown pragmas. 
#pragma warning disable 1634, 1691 

namespace Microsoft.Build.Tasks.Windows 
{
    #region GetWinFXPath Task class

    ///  
    /// Return the directory of current WinFX run time.
    ///  
    public sealed class GetWinFXPath : Task 
    {
        //----------------------------------------------------- 
        //
        //  Constructors
        //
        //----------------------------------------------------- 

        #region Constructors 
 
        /// 
        /// Constrcutor 
        /// 
        public GetWinFXPath()
            : base(SR.ResourceManager)
        { 

        } 
 
        #endregion Constructors
 
        //------------------------------------------------------
        //
        //  Public Methods
        // 
        //-----------------------------------------------------
 
        #region Public Methods 

        ///  
        /// ITask Execute method
        /// 
        /// 
        public override bool Execute() 
        {
            bool ret = true; 
 
            try
            { 
                TaskHelper.DisplayLogo(Log, SR.Get(SRID.GetWinFXPathTask));

                bool isWow64;
 
                isWow64 = IsWow64CLRRun();
 
                if (isWow64) 
                {
                    WinFXPath = WinFXWowPath; 
                }
                else
                {
                    WinFXPath = WinFXNativePath; 
                }
            } 
            catch (Exception e) 
            {
                // PreSharp Complaint 6500 - do not handle null-ref or SEH exceptions. 
                if (e is NullReferenceException || e is SEHException)
                {
                    throw;
                } 
                else
                { 
                    string message; 
                    string errorId;
 
                    errorId = Log.ExtractMessageCode(e.Message, out message);

                    if (String.IsNullOrEmpty(errorId))
                    { 
                        errorId = UnknownErrorID;
                        message = SR.Get(SRID.UnknownBuildError, message); 
                    } 

                    Log.LogError(null, errorId, null, null, 0, 0, 0, 0, message, null); 
                }

                ret = false;
            } 
#pragma warning disable 6500
            catch // Non-CLS compliant errors 
            { 
                Log.LogErrorWithCodeFromResources(SRID.NonClsError);
                ret = false; 
            }
#pragma warning restore 6500

 
            return ret;
        } 
 
        #endregion Public Methods
 
        //------------------------------------------------------
        //
        //  Public Properties
        // 
        //------------------------------------------------------
 
        #region Public Properties 

        ///  
        /// The path for native WinFX runtime.
        /// 
        [Required]
        public string WinFXNativePath 
        {
            get { return _winFXNativePath; } 
            set { _winFXNativePath = value; } 
        }
 
        /// 
        /// The path for WoW WinFX run time.
        /// 
        [Required] 
        public string WinFXWowPath
        { 
            get { return _winFXWowPath; } 
            set { _winFXWowPath = value; }
        } 

        /// 
        /// The real path for the WinFX runtime
        ///  
        [Output]
        public string WinFXPath 
        { 
            get { return _winFXPath;  }
            set { _winFXPath = value; } 
        }

        #endregion Public Properties
 

        //----------------------------------------------------- 
        // 
        //  Private Methods
        // 
        //------------------------------------------------------

        #region Private Methods
 
        // PInvoke delegate for IsWow64Process
        [UnmanagedFunctionPointer(CallingConvention.Winapi)] 
        private delegate bool IsWow64ProcessDelegate([In] IntPtr hProcess, [Out] out bool Wow64Process); 

        [DllImport(Kernel32Dll, PreserveSig = true, CharSet = CharSet.Unicode)] 
        private static extern IntPtr LoadLibrary(string fileName);

        [DllImport(Kernel32Dll, PreserveSig = true)]
        private static extern bool FreeLibrary([In] IntPtr module); 

        [DllImport(Kernel32Dll, PreserveSig = true, CharSet = CharSet.Unicode)] 
        private static extern IntPtr GetProcAddress(IntPtr module, string procName); 

        [DllImport(Kernel32Dll, PreserveSig = true)] 
        private static extern IntPtr GetCurrentProcess();

        // 
        // Detect if the msbuild is running under WOW64 environment. 
        // 
        static private bool IsWow64CLRRun() 
        { 
            bool isWow64 = false;
            IntPtr NullIntPtr = new IntPtr(0); 

            IntPtr kernel32Dll = LoadLibrary(Kernel32Dll);

            if (kernel32Dll != NullIntPtr) 
            {
                try 
                { 
                    IntPtr isWow64ProcessHandle = GetProcAddress(kernel32Dll, IsWow64ProcessMethodName);
 
                    // if the entry point is missing, it cannot be Wow64
                    if (isWow64ProcessHandle != NullIntPtr)
                    {
                        // entry point present, check if running in WOW64 
                        IsWow64ProcessDelegate isWow64Process = (IsWow64ProcessDelegate)Marshal.GetDelegateForFunctionPointer(isWow64ProcessHandle, typeof(IsWow64ProcessDelegate));
                        isWow64Process(GetCurrentProcess(), out isWow64); 
                    } 
                }
                finally 
                {
                    FreeLibrary(kernel32Dll);
                }
            } 

            return isWow64; 
        } 

 
        #endregion Private Methods

        //-----------------------------------------------------
        // 
        //  Private Properties
        // 
        //----------------------------------------------------- 

 
        //-----------------------------------------------------
        //
        //  Private Fields
        // 
        //------------------------------------------------------
 
        #region Private Fields 

        private string _winFXNativePath = string.Empty; 
        private string _winFXWowPath = string.Empty;
        private string _winFXPath = string.Empty;

        private const string UnknownErrorID = "FX1000"; 

        private const string Kernel32Dll = "kernel32.dll"; 
        private const string IsWow64ProcessMethodName = "IsWow64Process"; 

        #endregion Private Fields 

    }

    #endregion GetWinFXPath Task class 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
GetWinFXPath.cs source code in C# .NET

Source code for the .NET framework in C#

Code:

Link Menu
