C# 2005 Programmer’s Reference - chapter 26 ppt

ptg 580 CHAPTER 26 Interacting with the OS and Hardware //very important icon won’t show up without this! this.FlatStyle = FlatStyle.System; } } The Win32 class is a simple wrapper for P/Invoked functionality (see the section “Call Native Windows Functions Using P/Invoke” later in this chapter): class Win32 { [DllImport(“User32.dll”)] public static extern IntPtr SendMessage(HandleRef hWnd, UInt32 Msg, ➥IntPtr wParam, IntPtr lParam); //defined in CommCtrl.h public const UInt32 BCM_SETSHIELD = 0x0000160C; } It is impossible to elevate a process’s privileges once the process has started, so the technique is to start your same process as an admin and pass it some command-line arguments (or otherwise communicate with it) to tell it what to do. That second process will do the required behavior, then exit. Leaving the second, elevated, process running and having the first exit is not recommended—your programs should always run with the least privilege possible. Here is the button event handler (which has to do something requiring elevation): private void buttonCreateSource_Click(object sender, EventArgs e) { //you can’t elevate the current process you have to start a new one ProcessStartInfo startInfo = new ProcessStartInfo(); startInfo.FileName = Application.ExecutablePath; startInfo.Arguments = “-createEventSource”; //trigger the UAC prompt startInfo.Verb = “runas”; try { Process proc = Process.Start(startInfo); proc.WaitForExit(); } catch (Exception ex) { MessageBox.Show( “There was an error launching the elevated process: “ + ex.Message); } } From the Library of Skyla Walker ptg 581 Write to the Event Log Then, when the program starts, you can look for the arguments: [STAThread] static void Main() { string[] args = Environment.GetCommandLineArgs(); foreach (string arg in args) { if (string.Compare(“-createEventSource”, arg)==0) { //we should be running as admin now, so //attempt the privileged operation CreateEventSource(); //don’t need to show UI we’re already running it, //so just exit return; } } Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new Form1()); } Write to the Event Log Scenario/Problem: You want to write application events to the system event log so that administrators can use it. Solution: Windows provides an API for any application, service, and driver to write to a common logging interface, managed by the OS. .NET wraps this API into the EventLog and related classes. Before you can write to the event log, you need to do two things: 1. Create a log source. This is typically your application. This step requires admin- istrative privileges and only needs to be done once, so it’s typically done during application installation. 2. Decide which log your events should go to. By default, events are written to the Application event log, but you can create your own log as well. The code to create a log source is as follows: public const string LogName = “CSharpHowToLog”; //if you just want to put your messages in From the Library of Skyla Walker ptg 582 CHAPTER 26 Interacting with the OS and Hardware //the system-wide Application Log, do this: //public const string LogName = “Application”; public const string LogSource = “EventLogDemo”; private static void CreateEventSource() { //this functionality requires admin privileges //consider doing this during installation //of your app, rather than runtime if (!EventLog.SourceExists(LogSource)) { //to log to the general application log, pass in //null for the application name EventSourceCreationData data = new EventSourceCreationData(LogSource, LogName); EventLog.CreateEventSource(data); } } In the EventLogDemo sample app, CreateEventSource is called after a UAC request because it requires admin privileges. See the previous section for how to accomplish this. NOTE To do the actual logging, use the following: using (EventLog log = new EventLog(Program.LogName, “.”, Program.LogSource)) { int eventId = 13;//you define your own meaning for this log.WriteEntry(textBoxMessage.Text, EventLogEntryType.Information, eventId); } You could, of course, save the EventLog object in your application to reuse it, rather than disposing of it right away. Read from the Event Log You can use the same set of objects to read existing log entries: using (EventLog log = new EventLog(Program.LogName, “.”, Program.LogSource)) { StringBuilder sb = new StringBuilder(); foreach (EventLogEntry entry in log.Entries) { From the Library of Skyla Walker ptg 583 Access the Registry sb.AppendFormat(“({0}, {1} {2}) {3}”, entry.TimeGenerated, entry.InstanceId, entry.EntryType, entry.Message); sb.AppendLine(); } MessageBox.Show(sb.ToString(),”Existing events”); } Access the Registry Scenario/Problem: You need to read and/or write settings in the registry. Solution: Use the Registry and RegistryKey classes located in the Microsoft.Win32 namespace: //read from HKLM using (RegistryKey hklm = Registry.LocalMachine) using (RegistryKey keyRun = hklm.OpenSubKey(@”Software\Microsoft\Windows\CurrentVersion\Run”)) { foreach (string valueName in keyRun.GetValueNames()) { Console.WriteLine(“Name: {0}\tValue: {1}”, valueName, keyRun.GetValue(valueName)); } } Registry keys are represented by handles, which are system resources that must be disposed of, hence the using statements. NOTE //create our own registry key for the app //true indicates we want to be able to write to the subkey using (RegistryKey software = Registry.CurrentUser.OpenSubKey(@”Software”, true)) //volatile indicates that this key should be deleted //when the computer restarts using (RegistryKey myKeyRoot = software.CreateSubKey( “CSharp4HowTo”, RegistryKeyPermissionCheck.ReadWriteSubTree, RegistryOptions.Volatile)) From the Library of Skyla Walker ptg 584 CHAPTER 26 Interacting with the OS and Hardware { //automatically determine the type myKeyRoot.SetValue(“NumberOfChapters”, 28); //specify the type myKeyRoot.SetValue(“Awesomeness”, Int64.MaxValue, RegistryValueKind.QWord); //display what we just created foreach (string valueName in myKeyRoot.GetValueNames()) { Console.WriteLine(“{0}, {1}, {2}”, valueName, myKeyRoot.GetValueKind(valueName), myKeyRoot.GetValue(valueName)); } //remove from registry (set a breakpoint //here to go look at it in regedit) software.DeleteSubKeyTree(“CSharp4HowTo”); } Here’s the output from the preceding code: Name: iTunesHelper Value: “C:\Program Files (x86)\iTunes\ iTunesHelper.exe “ Name: OpenDNS Update Value: “C:\Program Files (x86)\OpenDNS Name: LifeCam Value: “C:\Program Files (x86)\Microsoft LifeCam\ LifeExp.exe “ NumberOfChapters, DWord, 28 Awesomeness, QWord, 9223372036854775807 In general, most .NET programs avoid the registry in favor of XML configura- tion files, but the access is there if you need it. Note that non-administrative programs don’t have write permissions on HKLM in Windows Vista and later. If you try to write to it as a non-administrator, Windows will actually redirect you to a virtual HKLM for just that application. Better just to avoid it. NOTE Manage Windows Services Scenario/Problem: You want to start, pause, and stop services from your application. From the Library of Skyla Walker ptg 585 Create a Windows Service Solution: You can control services (assuming you have the right privileges) with the System.ServiceProcess.ServiceController class: ServiceController controller = new ServiceController(“MyService”); controller.Start(); if (controller.CanPauseAndContinue) { controller.Pause(); controller.Continue(); } controller.Stop(); Create a Windows Service Scenario/Problem: You want to put your code in a service so that it is more easily manageable and can run when users are not logged in. There is nothing inherently different about a Windows service compared to an applica- tion except the manageability interfaces it implements (to allow it to be remotely controlled, automatically started and stopped, failed over to different machines, and so on). Also, a Windows service has no user interface (and security settings generally prohibit services from attempting to invoke a UI). You can generally use all the same .NET code as in a regular application. Solution: The heart of a service is a class that implements System.ServiceProcess.ServiceBase: public partial class GenericService : ServiceBase { Thread _programThread; bool _continueRunning = false; public GenericService() { InitializeComponent(); } protected override void OnStart(string[] args) { _continueRunning = true; LogString(“Service starting”); From the Library of Skyla Walker ptg 586 CHAPTER 26 Interacting with the OS and Hardware _programThread = new Thread(new ThreadStart(ThreadProc)); _programThread.Start(); } protected override void OnStop() { _continueRunning = false; LogString(“Service stopping”); } private void LogString(string line) { using (FileStream fs = new FileStream( @”C:\GenericService_Output.log”, FileMode.Append)) using (StreamWriter writer = new StreamWriter(fs)) { writer.WriteLine(line); } } private void ThreadProc() { while (_continueRunning) { Thread.Sleep(5000); LogString(string.Format(“{0} - Service running.”, DateTime.Now)); } } } This service does nothing interesting—it just logs events to a file. The Main function looks a little different: static void Main() { ServiceBase[] ServicesToRun; //yes, you can host multiple services in an executable file ServicesToRun = new ServiceBase[] { new GenericService() }; ServiceBase.Run(ServicesToRun); } From the Library of Skyla Walker ptg 587 Create a Windows Service This is the basic functionality for a service, but to make it easier to install the service, you should implement a few more classes: [RunInstaller(true)] public partial class ProjectInstaller : Installer { private System.ServiceProcess.ServiceProcessInstaller genericProcessInstaller; private System.ServiceProcess.ServiceInstaller genericServiceInstaller; public ProjectInstaller() { genericProcessInstaller = new System.ServiceProcess.ServiceProcessInstaller(); genericProcessInstaller.Account = System.ServiceProcess.ServiceAccount.LocalSystem; genericProcessInstaller.Password = null; genericProcessInstaller.Username = null; genericServiceInstaller = new System.ServiceProcess.ServiceInstaller(); genericServiceInstaller.ServiceName = “GenericService”; genericServiceInstaller.StartType = ➥System.ServiceProcess.ServiceStartMode.Automatic; this.Installers.AddRange( new System.Configuration.Install.Installer[] { genericProcessInstaller, genericServiceInstaller}); } } If you’re using Visual Studio, much of this work is automated for you. For example, you can right-click the design view of the service object and then select Add Installer to create this for you. NOTE With this installation class implemented, you can easily install the service into a system by using the .NET Framework tool InstallUtil.exe. To use this tool, start a Visual Studio command prompt with admin privileges and navigate to the directory containing the service executable and type: InstallUtil /i GenericService.exe From the Library of Skyla Walker ptg 588 CHAPTER 26 Interacting with the OS and Hardware To remove the service, type the following: InstallUtil /u GenericService.exe By default, services are not allowed to interact with the desktop. If you want a service to be able to do this, you need to modify the “Allow service to interact with desktop” setting in the service’s properties in the service management snap-in. NOTE Call Native Windows Functions Using P/Invoke Scenario/Problem: You want to call native Win32 API functions from .NET. Solution: Use P/Invoke, which is shorthand for Platform Invocation Services. It allows you to call native code directly from .NET. You’ve already seen some exam- ples throughout the book where we needed to supplement .NET’s functionality with that from the OS. Using P/Invoke involves defining any structures you will need in .NET and then adding an import reference to the function you want to call, potentially mapping each argument to equivalent types. Here’s an example of the declaration for the SendMessage function: [DllImport(“User32.dll”)] public static extern IntPtr SendMessage(HandleRef hWnd, UInt32 Msg, IntPtr wParam, IntPtr lParam); To call this, you would write the following: SendMessage(new HandleRef(this, this.Handle), MESSAGE_NUMBER, new IntPtr(0), new IntPtr(1)); A more sophisticated example is when you need the API function to fill in a structure: [StructLayout(LayoutKind.Sequential)] struct SYSTEM_INFO { public ushort wProcessorArchitecture; public ushort wReserved; public uint dwPageSize; public IntPtr lpMinimumApplicationAddress; public IntPtr lpMaximumApplicationAddress; public UIntPtr dwActiveProcessorMask; public uint dwNumberOfProcessors; From the Library of Skyla Walker ptg 589 Call C Functions in a DLL from C# public uint dwProcessorType; public uint dwAllocationGranularity; public ushort wProcessorLevel; public ushort wProcessorRevision; }; [DllImport(“kernel32.dll”)] static extern void GetNativeSystemInfo(ref SYSTEM_INFO lpSystemInfo); [DllImport(“kernel32.dll”)] static extern void GetSystemInfo(ref SYSTEM_INFO lpSystemInfo); A question that often arises is how to translate between various string representations. Windows natively uses C-style, NULL-terminated strings, whereas .NET uses the String object. The next section demonstrates how to do this. Call C Functions in a DLL from C# Scenario/Problem: You need to call a C-style function located in a DLL from C#. Solution: P/Invoke is most commonly used for calling the native API, but you can also use it to call native code functions in any unmanaged DLL. Listings 26.1–26.3 show the source code for a native code library that defines a C function that takes a char* argument. LISTING 26.1 MyCDll.h __declspec(dllexport) int SayHello(char* pszBuffer, int nLength); LISTING 26.2 MyCDll.cpp #include “stdafx.h” #include “MyCDll.h” #include <stdio.h> __declspec(dllexport) int SayHello(char* pszBuffer, int nLength) { ::strcpy_s(pszBuffer, nLength, “Hello, from C DLL”); return strlen(pszBuffer); } From the Library of Skyla Walker [...]... Visual Studio; see Figure 26. 1.) Your default choice should be Any CPU Because NET assemblies consist of byte code that is just-in-time compiled (JIT compiled) to the current platform at runtime, your assemblies will work on any architecture without rebuilding from the source code From the Library of Skyla Walker 592 CHAPTER 26 Interacting with the OS and Hardware FIGURE 26. 1 You can choose the target... needs to reference or interop with another managed assembly or unmanaged DLL that was compiled with a specific architecture, then your assembly needs to match Let’s look at an example Suppose you have the following: NET assembly: Any CPU 32-bit COM component On a 32-bit operating system, this scenario will work because the NET assembly will be just-in-time compiled as 32 bits However, on a 64-bit operating...590 CHAPTER 26 Interacting with the OS and Hardware LISTING 26. 3 MyCDll.def LIBRARY “MyCDll” EXPORTS SayHello See the MyCDll project in the examples for this chapter for the full source code On the C# side, using this function is quite easy This code also demonstrates that to call a method that takes... out of the question for most computers Memory-mapped files allow you to specify a portion of that file to load into memory, where you can then manipulate it much as any other in-memory structure, such as an array, and the changes are written back to the file automatically From the Library of Skyla Walker Ensure Your Application Works in Both 32-bit and 64-bit Environments 591 static void Main(string[]... Running this on a text file will result in a sequence of E and O characters being written in the middle Ensure Your Application Works in Both 32-bit and 64-bit Environments Scenario/Problem: You want to ensure your application runs correctly on both 32-bit and 64-bit operating systems Solution: This is a simple configuration setting, with some caveats In your project’s build options, you can select the... static events your application can listen to, such as the following: DisplaySettingsChanged (and -Changing) InstalledFontsChanged PaletteChanged PowerModeChanged SessionEnded (the user is logging off; also -Ending) SessionSwitch (the current use has changed) TimeChanged UserPreferenceChanged (and -Changing) For example, if your application listens for the PowerModeChanged event, you can detect... page intentionally left blank From the Library of Skyla Walker CHAPTER 27 Fun Stuff and Loose Ends IN THIS CHAPTER Create a Nonrectangular Window Create a Notification Icon Create a Screen Saver in WPF Show a Splash Screen Play a Sound File Shuffle Cards From the Library of Skyla Walker 598 CHAPTER 27 Fun Stuff and Loose Ends This chapter has a few topics that are slightly more frivolous than... return value: {1}”, result, returnVal); } Use Memory-Mapped Files Scenario/Problem: You want to access a file as if it were a memory buffer, or you need to access a file that is too large to put entirely in memory Solution: Memory-mapped files are not the most often used technology, but when you need them, they are very good at what they do Memory-mapped files are exactly what they sound like: A portion... public RECT(int left, int top, int right, int bottom) { Left = left; Top = top; Right = right; Bottom = bottom; } public int Height { get { return Bottom - Top; } } public int Width { get { return Right - Left; } } } From the Library of Skyla Walker 614 CHAPTER 27 Fun Stuff and Loose Ends [DllImport(“user32.dll”)] public static extern bool GetWindowRect(IntPtr hWnd, out RECT lpRect); } } Show a Splash... //then tell Windows we’re clicking on the non-client area Win32.ReleaseCapture(); Win32.SendMessage(this.Handle, Win32.WM_NCLBUTTONDOWN, Win32.HTCAPTION, 0); } private void buttonClose_Click(object sender, EventArgs e) { Application.Exit(); } Figure 27.2 shows our custom window shape in action, complete with transparency From the Library of Skyla Walker 600 CHAPTER 27 Fun Stuff and Loose Ends FIGURE . assembly: Any CPU . 32-bit COM component On a 32-bit operating system, this scenario will work because the .NET assembly will be just-in-time compiled as 32 bits. However, on a 64-bit operating system,. Skyla Walker ptg 590 CHAPTER 26 Interacting with the OS and Hardware LISTING 26. 3 MyCDll.def LIBRARY “MyCDll” EXPORTS SayHello See the MyCDll project in the examples for this chapter for the full. middle. Ensure Your Application Works in Both 32-bit and 64-bit Environments Scenario/Problem: You want to ensure your application runs correctly on both 32-bit and 64-bit operating systems. Solution: This