2019年12月9日 星期一

Entering leading zeroes in Excel

By default, Microsoft Excel won't display or store leading zeros. Read this Excel tip to learn three handy ways to get around the problem.
Leading zeros are those pesky place-holding 0 digits at the beginning of a number. Unfortunately, when you enter such a value, Excel applies the General numeric format and tosses out the leading zero. Excel won't display or store the leading 0 digit (see the Formula bar).
ex1.jpg
When these values are text -- part numbers, ZIP codes, and so on -- you don't have a problem. Simply precede the value with an apostrophe character ('). You can tell the value is text because it's left-aligned and you can see the apostrophe in the Formula bar.
ex2.jpg
Sometimes, these entries are true numeric values and you will need to evaluate them in mathematical processes. When this is the case, you can force Excel to display placeholder 0 digits by applying a custom format as follows:
  1. Select the cell or range in question.
  2. Right-click the selected cell or range and choose Format Cells from the context menu.
  3. Click the Number tab.
  4. Choose Custom from the Category list.
  5. In the Type field, enter the number of 0s necessary to accommodate the largest value. For instance, if the largest value contains four digits, enter four 0s.
ex3.jpg
6. Click OK and Excel displays leading values
ex4.jpg
Your users can enter the leading zero(s), or not -- Excel won't care. However, this particular format doesn't work with decimal values. If you enter the value .7, the format rounds the value to 1. To accommodate decimal values, enter placeholders for the appropriate number of digits. For instance, if your want Excel to display four digits to the left and two digits to the right of the decimal, enter the custom format 0000.00.
ex5.jpg

2019年11月4日 星期一

"mailbox full" in outlook even when it's not

Make sure that your mailbox is not full, you can do 1 of the following things:
1. Run “Get-MailboxStatistics alias | fl StorageLimitStatus” on your Exchange server in the Exchange Management Shell
2. Log on to OWA and hover your mouse on your name in the left upper corner. A window will appear that tells you your mailbox current size and its maximum size.
3. Log on to the server. In the Recipients Configuration, check the current mailbox size of the user, and check the quota limit (tab Mailbox settings –> Storage quotas)
Once you’ve verified that your mailbox is NOT full (so the full mailbox notification is incorrect), you should do the following:
1. Open Outlook, click File (left top), Click Account Settings, double click your account name, and then uncheck “Use Cached Exchange Mode” and finish the wizard
2. Close Outlook. Delete your OST file. The default location for you OST-file on Windows  is C:\Users\user\AppData\Local\Microsoft\Outlook\. Either copy and paste the path in Windows Explorer, OR Enable Hidden Folders to view the AppData folder.
3. Open Outlook again and enable Cached Exchange Mode again (like you did in step 1, but now recheck)

2019年11月3日 星期日

Clearing up Event Id 1030

I was getting lots of Event Id 1030 errors on a workstation — “Windows cannot query for the list of Group Policy objects”. I know I am not the only one to have seen these errors in their event logs. Microsoft CSS posted the following reg edit patch which cleared up the Event 1030 errors on my workstation:

Remove Bad Stored Credentials from the Credential Manager:

1. Run Regedit2. Drill down to HKLM\System\CurrentControlSet\Control\Lsa
3. In the right pane locate the disabledomaincreds key
4. Change the disabledomaincreds value to to stop store domain credentials.

2019年9月19日 星期四

How to Extend Office 2016 / Office 365 Trial to 180 Days

How to Extend Office 2016 / Office 365 Trial to 180 Days

Like in earlier Office versions, when installing Office 2016 or Office 365 a user is offered to try the product for free for 30 days. In 30 days some of the Office features are blocked, and a user is prompted to purchase a license and activate the product (using a retail/MAK key or a KMS activation), or to uninstall Office completely. However, there is a little trick that allows you to extend Microsoft Office free trial period to 180 days.
your trial has expired office 2016 / 365
MS Office 2016 / Office 365 includes a special tool, ospprearm.exe, which is located in the directory:
  1. On 64-bit Windows versions with 32-bit Office version installed — %SystemDrive%\Program Files (x86)\Microsoft Office\Office16
  2. In other cases — %SystemDrive%\Program Files\Microsoft Office\Office16
Note. Sometimes the file may be located in:
%SystemDrive%\Program Files (x86)\Common Files\Microsoft shared\OfficeSoftwareProtectionPlatform\
Or
%SystemDrive%\Common Files\Microsoft shared\OfficeSoftwareProtectionPlatform\
ospprearm.exe - tool to extend office trial
Open the command prompt as an administrator, and run the following command to change the directory:
Cd %SystemDrive%\Program Files (x86)\Microsoft Office\Office16
To extend your trial version of Office for 30 days, run this command:
OSPPREARM.EXE
Microsoft Office rearm successful
The following message will appear: Microsoft Office rearm successful.
Thus, you rearm your Office 2016 / 365 and extend free trial to 30 days. You can run this command up to five (5) times on every 30 day of trial. Thus, you can extend the time of using the Office 2016 trial version up to 180 days (6 * 30 days). You can see the current activation status the number of days left for the grace period to end as follows.
cscript ospp.vbs /dstatus
Tip. This opportunity to extend the Office trial period is described on Microsoft website. However, it may be considered a violation of the license agreement. So you postpone the activation at your own risk.
You can rearm your Office 2010/2013 trial version in the same way.

2019年9月9日 星期一

Scrcpy 免裝 App 讓 Android 手機投影到電腦,還可電腦操控

Scrcpy 免裝 App 讓 Android 手機投影到電腦,還可電腦操控


出處: https://www.playpcesor.com/2019/08/scrcpy-app-android.html


如果你是需要進行數位工具教學的老師,或是 App 開發者、行銷人員,可能常常需要在電腦上「秀出你的手機畫面,進行 App 操作示範」,這時候,就需要一個好用的手機投影電腦工具。

我自己也有這樣的需求,所以在電腦玩物多年來做了許多的研究,在不同的機型裝備上,可能有下面幾個適用的選擇:


上面幾個工具,可以免費滿足基本的需求。

但在我自己幾番嘗試後,這一年多以來,我自己固定使用的則是後面這個付費的軟體:「AirServer 在 Windows 同時鏡像投影 iPhone iPad Android 螢幕」,因為它穩定、解析度高、可無線操作。




最近,則看到有朋友分享這款:「 Scrcpy 」,這是一款免費免安裝軟體,在 Android 上也無須安裝 App ,就能很順暢也很穩定的完成 Android 投影到電腦的任務。並且還能從電腦操作 Android 手機畫面。

我先總結自己測試「 Scrcpy 」後發現的幾點優點:

  • USB 連線投影,不需網路,非常穩定
  • 連線與反應速度都非常快
  • 免安裝 App 與軟體
  • 可從電腦用滑鼠操控手機
  • 可從電腦輸入中文內容到手機

因為是免安裝軟體,所以當我到不同學校、企業的電腦教室上課時,也可以簡單下載這個免安裝軟體,完成我需要的手機投影到電腦需求。



那麼,接下來我就快速介紹一下「 Scrcpy 」的設定流程。

在 Andorid 手機上不需要安裝任何 App ,但須要啟動開發者模式。

來到你的 Android 手機的[設定],進入[關於手機]的頁面,[連續點擊]關於頁面最下方的[版本號碼]。

當連續點擊這個版本號欄位許多次後,就會讓手機打開開發人員模式。




這時候,回到 Android 手機的設定畫面,找到[開發人員選項]。(每台 Android 手機的選單位置可能不同,我的是在[系統]頁面當中)

在[開發人員選項]中,開啟[ USB 偵錯]。




接著,用一條 USB 連接線,將手機接上你要投影的電腦, 電腦會自動安裝需要的驅動程式,在 Windows 10 或 7 我測試都可以成功。

這時候,在 Android 手機上應該會跳出[允許 USB 偵錯嗎?]的畫面,要選擇[確定],來允許這部電腦與手機連線。




接著在電腦上,到「 Scrcpy 」網站,下載和你的電腦作業系統對應的軟體。

以 Windows 電腦為例,在網站中往下捲動頁面,捲動到[ Windows ]軟體下載處,下載 32 位元或 64 位元版本。




下載到電腦後,直接解壓縮,不需要安裝,啟動資料夾中的「 Scrcpy.exe 」程式即可。

如果第一次啟動 Scrcpy 時出現失敗,沒有關係,這時候看你的手機畫面,應該會彈出需要允許信任這台電腦的視窗,點擊確認。




這樣一來,以後只要:

  • Android 手機用 USB 線連接到電腦。
  • 在電腦上啟動「 Scrcpy 」免安裝軟體。

那麼電腦上就會出現 Android 手機的投影畫面囉!

除了不需網路、穩定、速度快等優點外。

「 Scrcpy 」不只可以在電腦投影手機畫面,還可以從電腦端,用滑鼠點選的方式來操作手機上的 App 。




甚至從電腦端打字,也可以傳送到 Android 手機。

不過這邊需要一點小技巧,方法如下:

電腦端的輸入法要先切換到「英文鍵盤模式」,接著滑鼠點選 Android 手機投影畫面的 App 輸入欄位,彈出手機上的輸入法(我是用 Gboard ),這時候直接在電腦端打字,就好像敲擊手機鍵盤一樣,可以透過手機輸入法來輸入文字囉!




雖然「 Scrcpy 」有很多優點,不過我也跟自己慣用的「 AirServer 」做了比較。

這時候「 Scrcpy 」有一個明顯缺點,就是他的投影畫質比較模糊,而「 AirServer 」可以做到非常清晰的投影畫質。

下圖中,第一張圖是「 AirServer 」,第二張圖是「 Scrcpy 」,大家可以放大看原圖,實際比較看看。

我也總結一下「 AirServer 」作為對比的優缺點:

  • 電腦、手機要在同一個無線網路上,但相對的不需要連接線就能投影。
  • 反應速度會根據無線網路的速度而有差別。
  • 畫質非常清晰。
  • 需要在電腦端、手機端安裝軟體。
  • 不能從電腦操控手機。

大家可以跟前面的 「 Scrcpy 」優點做一個對比。





如果你可以順利完成基本的設定,那麼「 Scrcpy 」看起來確實是一款非常好用的 Android 投影電腦軟體。推薦給有需要的朋友試試看。

「 Scrcpy 」網站

2019年8月30日 星期五

How to: Determine which .NET Framework versions are installed

How to: Determine which .NET Framework versions are installed

Users can install and run multiple versions of the .NET Framework on their computers. When you develop or deploy your app, you might need to know which .NET Framework versions are installed on the user’s computer.
The .NET Framework consists of two main components, which are versioned separately:
  • A set of assemblies, which are collections of types and resources that provide the functionality for your apps. The .NET Framework and assemblies share the same version number.
  • The common language runtime (CLR), which manages and executes your app's code. The CLR is identified by its own version number (see Versions and Dependencies).
 Note
Each new version of the .NET Framework retains features from the previous versions and adds new features. You can load multiple versions of the .NET Framework on a single computer at the same time, which means that you can install the .NET Framework without having to uninstall previous versions. In general, you shouldn't uninstall previous versions of the .NET Framework, because an application you use may depend on a specific version and may break if that version is removed.
There is a difference between the .NET Framework version and the CLR version:
  • The .NET Framework version is based on the set of assemblies that form the .NET Framework class library. For example, .NET Framework versions include 4.5, 4.6.1, and 4.7.2.
  • The CLR version is based on the runtime on which .NET Framework applications execute. A single CLR version typically supports multiple .NET Framework versions. For example, CLR version 4.0.30319.xxxxx supports .NET Framework versions 4 through 4.5.2, where xxxxx is less than 42000, and CLR version 4.0.30319.42000 supports .NET Framework versions starting with .NET Framework 4.6.
For more information about versions, see .NET Framework versions and dependencies.
To get a list of the .NET Framework versions installed on a computer, you access the registry. You can either use the Registry Editor to view the registry or use code to query it:
To get a list of the CLR versions installed on a computer, use a tool or code:
For information about detecting the installed updates for each version of the .NET Framework, see How to: Determine which .NET Framework updates are installed.

Find newer .NET Framework versions (4.5 and later)

Find .NET Framework versions 4.5 and later in the registry

  1. From the Start menu, choose Run, enter regedit, and then select OK.
    You must have administrative credentials to run regedit.
  2. In the Registry Editor, open the following subkey: HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full. If the Full subkey isn't present, then you don't have the .NET Framework 4.5 or later installed.
     Note
    The NET Framework Setup folder in the registry does not begin with a period.
  3. Check for a DWORD entry named Release. If it exists, then you have .NET Framework 4.5 or later versions installed. Its value is a release key that corresponds to a particular version of the .NET Framework. In the following figure, for example, the value of the Release entry is 378389, which is the release key for .NET Framework 4.5.
    Registry entry for the .NET Framework 4.5
The following table lists the value of the Release DWORD on individual operating systems for .NET Framework 4.5 and later versions.
 Important
The following table lists the keys of released versions of the .NET Framework only. It doesn't list the keys of preview or pre-release versions.
.NET Framework versionValue of the Release DWORD
.NET Framework 4.5All Windows operating systems: 378389
.NET Framework 4.5.1On Windows 8.1 and Windows Server 2012 R2: 378675
On all other Windows operating systems: 378758
.NET Framework 4.5.2All Windows operating systems: 379893
.NET Framework 4.6On Windows 10: 393295
On all other Windows operating systems: 393297
.NET Framework 4.6.1On Windows 10 November Update systems: 394254
On all other Windows operating systems (including Windows 10): 394271
.NET Framework 4.6.2On Windows 10 Anniversary Update and Windows Server 2016: 394802
On all other Windows operating systems (including other Windows 10 operating systems): 394806
.NET Framework 4.7On Windows 10 Creators Update: 460798
On all other Windows operating systems (including other Windows 10 operating systems): 460805
.NET Framework 4.7.1On Windows 10 Fall Creators Update and Windows Server, version 1709: 461308
On all other Windows operating systems (including other Windows 10 operating systems): 461310
.NET Framework 4.7.2On Windows 10 April 2018 Update and Windows Server, version 1803: 461808
On all Windows operating systems other than Windows 10 April 2018 Update and Windows Server, version 1803: 461814
.NET Framework 4.8On Windows 10 May 2019 Update: 528040
On all others Windows operating systems (including other Windows 10 operating systems): 528049
You can use these values as follows:
  • To determine whether a specific version of the .NET Framework is installed on a particular version of the Windows operating system, test whether the Release DWORD value is equal to the value listed in the table. For example, to determine whether .NET Framework 4.6 is present on a Windows 10 system, test for the a Release value that is equal to 393295.
  • To determine whether a minimum version of the .NET Framework is present, use the smaller RELEASE DWORD value for that version. For example, if your application runs under .NET Framework 4.6 or a later version, test for a RELEASE DWORD value that is greater than or equal to 393295. For a table that lists only the minimum RELEASE DWORD value for each .NET Framework version, see The minimum values of the Release DWORD for .NET Framework 4.5 and later versions.
  • To test for multiple versions, begin by testing for a value that is greater than or equal to the smaller DWORD value for the latest .NET Framework version, and then compare the value with the smaller DWORD value for each successive earlier version. For example, if your application requires .NET Framework 4.7 or later and you want to determine the specific version of .NET Framework present, start by testing for a RELEASE DWORD value that is great than or equal to to 461808 (the smaller DWORD value for .NET Framework 4.7.2). Then compare the RELEASE DWORD value with the smaller value for each later .NET Framework version. For a table that lists only the minimum RELEASE DWORD value for each .NET Framework version, see The minimum values of the Release DWORD for .NET Framework 4.5 and later versions.

Find .NET Framework versions 4.5 and later with code

  1. Use the RegistryKey.OpenBaseKey and RegistryKey.OpenSubKey methods to access the HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full subkey in the Windows registry.
    The existence of the Release DWORD entry in the HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full subkey indicates that the .NET Framework 4.5 or a later version is installed on a computer.
  2. Check the value of the Release entry to determine the installed version. To be forward-compatible, check for a value greater than or equal to the value listed in the .NET Framework version table.
The following example checks the value of the Release entry in the registry to find the .NET Framework 4.5 and later versions that are installed:
C#
using System;
using Microsoft.Win32;

public class GetDotNetVersion
{
   public static void Main()
   {
      Get45PlusFromRegistry();
   }

   private static void Get45PlusFromRegistry()
   {
      const string subkey = @"SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full\";

      using (var ndpKey = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry32).OpenSubKey(subkey))
      {
        if (ndpKey != null && ndpKey.GetValue("Release") != null) {
            Console.WriteLine($".NET Framework Version: {CheckFor45PlusVersion((int) ndpKey.GetValue("Release"))}");
        }
         else {
            Console.WriteLine(".NET Framework Version 4.5 or later is not detected.");
         } 
      }
   
      // Checking the version using >= enables forward compatibility.
      string CheckFor45PlusVersion(int releaseKey)
      {
         if (releaseKey >= 528040)
            return "4.8 or later";
         if (releaseKey >= 461808)
            return "4.7.2";
         if (releaseKey >= 461308)
            return "4.7.1";
         if (releaseKey >= 460798)
            return "4.7";
         if (releaseKey >= 394802)
            return "4.6.2";
         if (releaseKey >= 394254)
            return "4.6.1";      
         if (releaseKey >= 393295)
            return "4.6";      
         if (releaseKey >= 379893)
            return "4.5.2";      
         if (releaseKey >= 378675)
            return "4.5.1";      
         if (releaseKey >= 378389)
            return "4.5";      
         // This code should never execute. A non-null release key should mean
         // that 4.5 or later is installed.
         return "No 4.5 or later version detected";
      }
   }
}   
// This example displays output like the following:
//       .NET Framework Version: 4.6.1
This example follows the recommended practice for version checking:
  • It checks whether the value of the Release entry is greater than or equal to the value of the known release keys.
  • It checks in order from most recent version to earliest version.

Check for a minimum-required .NET Framework version (4.5 and later) with PowerShell

  • Use PowerShell commands to check the value of the Release entry of the HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full subkey.
The following examples check the value of the Release entry to determine whether the .NET Framework 4.6.2 or later is installed. This code returns True if it's installed and False otherwise.
PowerShell
# PowerShell 5
 Get-ChildItem 'HKLM:\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full\' |  Get-ItemPropertyValue -Name Release | Foreach-Object { $_ -ge 394802 }
PowerShell
# PowerShell 4
(Get-ItemProperty "HKLM:SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full").Release -ge 394802
To check for a different minimum-required .NET Framework version, replace 394802 in these examples with a Release value from the .NET Framework version table.

Find older .NET Framework versions (1–4)

Find .NET Framework versions 1–4 in the registry

  1. From the Start menu, choose Run, enter regedit, and then select OK.
    You must have administrative credentials to run regedit.
  2. In the Registry Editor, open the following subkey: HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP:
    • For .NET Framework versions 1.1 through 3.5, each installed version is listed as a subkey under the HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP subkey. For example, HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP\v3.5. The version number is stored as a value in the version subkey's Version entry.
    • For .NET Framework 4, the Version entry is under the HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4.0\Client subkey, the HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4.0\Full subkey, or under both subkeys.
     Note
    The NET Framework Setup folder in the registry does not begin with a period.
    The following figure shows the subkey and its Version entry for the .NET Framework 3.5.
    The registry entry for the .NET Framework 3.5.

Find .NET Framework versions 1–4 with code

  • Use the Microsoft.Win32.RegistryKey class to access the HKEY_LOCAL_MACHINE\Software\Microsoft\NET Framework Setup\NDP subkey in the Windows registry.
The following example finds the .NET Framework 1–4 versions that are installed:
C#
using Microsoft.Win32;
using System;

public static class VersionTest
{
    public static void Main()
    {
        GetVersionFromRegistry();
    }
    
    private static void GetVersionFromRegistry()
    {
        // Opens the registry key for the .NET Framework entry.
        using (RegistryKey ndpKey = 
                RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry32).
                OpenSubKey(@"SOFTWARE\Microsoft\NET Framework Setup\NDP\"))
        {
            foreach (var versionKeyName in ndpKey.GetSubKeyNames())
            {
                // Skip .NET Framework 4.5 version information.
                if (versionKeyName == "v4")
                {
                    continue;
                }

                if (versionKeyName.StartsWith("v"))
                {

                    RegistryKey versionKey = ndpKey.OpenSubKey(versionKeyName);
                    // Get the .NET Framework version value.
                    var name = (string)versionKey.GetValue("Version", "");
                    // Get the service pack (SP) number.
                    var sp = versionKey.GetValue("SP", "").ToString();

                    // Get the installation flag, or an empty string if there is none.
                    var install = versionKey.GetValue("Install", "").ToString();
                    if (string.IsNullOrEmpty(install)) // No install info; it must be in a child subkey.
                        Console.WriteLine($"{versionKeyName}  {name}");
                    else
                    {
                        if (!(string.IsNullOrEmpty(sp)) && install == "1")
                        {
                            Console.WriteLine($"{versionKeyName}  {name}  SP{sp}");
                        }
                    }
                    if (! string.IsNullOrEmpty(name))
                    {
                        continue;
                    }
                    foreach (var subKeyName in versionKey.GetSubKeyNames())
                    {
                        RegistryKey subKey = versionKey.OpenSubKey(subKeyName);
                        name = (string)subKey.GetValue("Version", "");
                        if (! string.IsNullOrEmpty(name))
                            sp = subKey.GetValue("SP", "").ToString();
                        
                        install = subKey.GetValue("Install", "").ToString();
                        if (string.IsNullOrEmpty(install)) //No install info; it must be later.
                            Console.WriteLine($"{versionKeyName}  {name}");
                        else
                        {
                            if (!(string.IsNullOrEmpty(sp )) && install == "1")
                            {
                                Console.WriteLine($"{subKeyName}  {name}  SP{sp}");
                            }
                            else if (install == "1")
                            {
                                Console.WriteLine($"  {subKeyName}  {name}");
                            }
                        }
                    }
                }
            }
        }
    }
}
// The example displays output similar to the following:
//        v2.0.50727  2.0.50727.4927  SP2
//        v3.0  3.0.30729.4926  SP2
//        v3.5  3.5.30729.4926  SP1
//        v4.0
//        Client  4.0.0.0

Find CLR versions

Find the current CLR version with Clrver.exe

Use the CLR Version tool (Clrver.exe) to determine which versions of the CLR are installed on a computer:

Find the current CLR version with the Environment class

 Important
For the .NET Framework 4.5 and later versions, don't use the Environment.Version property to detect the version of the CLR. Instead, query the registry as described in Find .NET Framework versions 4.5 and later with code.
  1. Query the Environment.Version property to retrieve a Version object.
    The returned System.Version object identifies the version of the runtime that's currently executing the code. It doesn't return assembly versions or other versions of the runtime that may have been installed on the computer.
    For the .NET Framework versions 4, 4.5, 4.5.1, and 4.5.2, the string representation of the returned Version object has the form 4.0.30319.xxxxx, where xxxxx is less than 42000. For the .NET Framework 4.6 and later versions, it has the form 4.0.30319.42000.
  2. After you have the Version object, query it as follows:
    • For the major release identifier (for example, 4 for version 4.0), use the Version.Major property.
    • For the minor release identifier (for example, 0 for version 4.0), use the Version.Minor property.
    • For the entire version string (for example, 4.0.30319.18010), use the Version.ToString method. This method returns a single value that reflects the version of the runtime that's executing the code. It doesn't return assembly versions or other runtime versions that may be installed on the computer.
The following example uses the Environment.Version property to retrieve CLR version information:
C#
using System;

public class VersionTest
{
    public static void Main()
    {
        Console.WriteLine($"Version: {Environment.Version}");
    }
}
// The example displays output similar to the following:'
//    Version: 4.0.30319.18010