C# – Visual Basic Bilingual Dictionary (2015)
Chapter 3
My Namespace to C#
The Visual Basic My namespace entries in this chapter appear alphabetically according to each member name within the hierarchy. For example, to discover the C# equivalent to the My.Computer.Network.IsAvailable property, locate the “IsAvailable Property” entry.
Some of the C# code samples in this chapter provide reasonable, but not exact, equivalents for My namespace members. For example, some members return a read-only collection of results, but the provided C# code might return an array or a generic collection instead.
Some My namespace members perform validation on data supplied to those members. In many cases, the provided C# code simplifies or eliminates such validation, providing just a basic translation for the My namespace member.
The full source code for the My namespace, written in Visual Basic, is available online. Visit http://referencesource.microsoft.com to access the code.
AllUsersApplicationData Property
♦ My.Computer.FileSystem.SpecialDirectories.AllUsersApplicationData
Returns the path to the “application data” folder shared by all local users.
VISUAL BASIC
Dim result As String = My.Computer.FileSystem.
SpecialDirectories.AllUsersApplicationData
C#
string result = System.Environment.GetFolderPath(
System.Environment.SpecialFolder.
CommonApplicationData);
AltKeyDown Property
♦ My.Computer.Keyboard.AltKeyDown
Indicates whether an Alt key is currently pressed.
VISUAL BASIC
Dim result As Boolean = My.Computer.Keyboard.AltKeyDown
C#
// ----- For Windows Forms code:
bool result = ((System.Windows.Forms.Control.ModifierKeys &
System.Windows.Forms.Keys.Alt) != 0);
// ----- For XAML-centric code:
bool result = ((System.Windows.Input.Keyboard.Modifiers &
System.Windows.Input.ModifierKeys.Alt) != 0);
ApplicationContext Property
♦ My.Application.ApplicationContext
Returns the application context for the current application or thread.
VISUAL BASIC
Dim result As System.Windows.Forms.ApplicationContext =
My.Application.ApplicationContext
If you start a Windows Forms application by passing in a custom context, this instance is normally not accessible within the application. You must preserve a reference to it in your code if you want to access later.
C#
static class Program
{
// ----- Assumes that a LocalContext class derived
// from System.Windows.Forms.ApplicationContext
// has been defined elsewhere.
private static LocalContext TheContext = null;
[STAThread]
static void Main()
{
Program.TheContext = new LocalContext();
Program.TheContext.MainForm = new Form1();
Application.Run(Program.TheContext);
}
public static LocalContext GetContext
{
get
{
return Program.TheContext;
}
}
}
AssemblyName Property
♦ My.Application.Info.AssemblyName
Retrieves the simple name of the assembly, with the file extension removed.
VISUAL BASIC
Dim result As String = My.Application.Info.AssemblyName
C#
System.Reflection.Assembly currentAssembly =
System.Reflection.Assembly.GetEntryAssembly();
if (currentAssembly == null) currentAssembly =
System.Reflection.Assembly.GetCallingAssembly();
string result = currentAssembly.GetName().Name;
Audio Object
♦ My.Computer.Audio
See
Play Method, PlaySystemSound Method, Stop Method
AvailablePhysicalMemory Property
♦ My.Computer.Info.AvailablePhysicalMemory
Returns the total number of free bytes of physical memory on the local computer.
VISUAL BASIC
Dim result As ULong =
My.Computer.Info.AvailablePhysicalMemory
C#
// ----- GetMemoryInfo code discussed below.
ulong result = MemoryQuery.GetMemoryInfo().AvailPhysical;
Visual Basic retrieves memory information through the GlobalMemoryStatusEx Windows API call. The following code wraps the API call in C# code, and returns a Win32-compatible structure containing the memory information.
C#
// ----- This code works only with Windows 2000 and beyond.
public class MemoryQuery
{
[System.Runtime.InteropServices.StructLayoutAttribute(
System.Runtime.InteropServices.LayoutKind.
Sequential)]
public struct MemoryInfo
{
public uint DataLength;
public uint MemoryLoad;
public ulong TotalPhysical;
public ulong AvailPhysical;
public ulong TotalPageFile;
public ulong AvailPageFile;
public ulong TotalVirtual;
public ulong AvailVirtual;
public ulong AvailExtendedVirtual;
public void Initialize()
{
// ----- The API must know the return size.
this.DataLength = (uint)System.Runtime.
InteropServices.Marshal.SizeOf(
typeof(MemoryInfo));
}
}
[System.Runtime.InteropServices.DllImportAttribute(
"kernel32.dll", EntryPoint="GlobalMemoryStatusEx")]
[return: System.Runtime.InteropServices.
MarshalAsAttribute(System.Runtime.
InteropServices.UnmanagedType.Bool)]
public static extern bool GlobalMemoryStatusEx(
[System.Runtime.InteropServices.OutAttribute()]
out MemoryInfo memoryDetails);
public static MemoryInfo GetMemoryInfo()
{
MemoryQuery.MemoryInfo memoryDetails =
new MemoryQuery.MemoryInfo();
memoryDetails.Initialize();
if (MemoryQuery.GlobalMemoryStatusEx(
out memoryDetails))
return memoryDetails;
else
throw new System.Exception(
"Failed to retrieve memory information.");
}
}
AvailableVirtualMemory Property
♦ My.Computer.Info.AvailableVirtualMemory
Returns the total number of free bytes of virtual memory on the local computer.
VISUAL BASIC
Dim result As ULong =
My.Computer.Info.AvailableVirtualMemory
C#
// ----- GetMemoryInfo code discussed below.
ulong result = MemoryQuery.GetMemoryInfo().AvailVirtual;
Visual Basic retrieves memory information through the GlobalMemoryStatusEx Windows API call. See the “AvailablePhysicalMemory Property” entry in this chapter for a sample GetMemoryInfo method that wraps the API call in C# code.
ButtonsSwapped Property
♦ My.Computer.Mouse.ButtonsSwapped
Indicates whether the standard arrangement of the two primary mouse buttons has been reversed.
VISUAL BASIC
Dim result As Boolean = My.Computer.Mouse.ButtonsSwapped
C#
// ----- For Windows Forms code:
bool result = System.Windows.Forms.SystemInformation.
MouseButtonsSwapped;
// ----- For XAML-centric code:
bool result = System.Windows.SystemParameters.SwapButtons;
CapsLock Property
♦ My.Computer.Keyboard.CapsLock
Indicates whether the Caps Lock key is currently activated.
VISUAL BASIC
Dim result As Boolean = My.Computer.Keyboard.CapsLock
C#
// ----- For Windows Forms code:
bool result = System.Windows.Forms.Form.IsKeyLocked(
System.Windows.Forms.Keys.CapsLock);
// ----- For XAML-centric code:
bool result = System.Windows.Input.Keyboard.IsKeyToggled(
System.Windows.Input.Key.CapsLock);
ChangeCulture Method
♦ My.Application.ChangeCulture
Given a culture code (such as en-US), changes the current culture used for formatting certain values, such as numbers and dates.
VISUAL BASIC
My.Application.ChangeCulture("en-US")
C#
System.Threading.Thread.CurrentThread.CurrentCulture =
new System.Globalization.CultureInfo("en-US");
ChangeUICulture Method
♦ My.Application.ChangeUICulture
Given a culture code (such as en-US), changes the current culture used for the user interface.
VISUAL BASIC
My.Application.ChangeUICulture("en-US")
C#
System.Threading.Thread.CurrentThread.CurrentUICulture =
new System.Globalization.CultureInfo("en-US");
ClassesRoot Property
♦ My.Computer.Registry.ClassesRoot
Returns a reference to the HKEY_CLASSES_ROOT Windows registry location.
VISUAL BASIC
Dim result As Microsoft.Win32.RegistryKey =
My.Computer.Registry.ClassesRoot
C#
Microsoft.Win32.RegistryKey result =
Microsoft.Win32.Registry.ClassesRoot;
Clear Method
♦ My.Computer.Clipboard.Clear
Removes all data from the system clipboard.
VISUAL BASIC
My.Computer.Clipboard.Clear()
C#
// ----- For Windows Forms code:
System.Windows.Forms.Clipboard.Clear();
// ----- For XAML-centric code:
System.Windows.Clipboard.Clear();
Clipboard Object
♦ My.Computer.Clipboard
See
Clear Method, ContainsAudio Method, ContainsData Method, ContainsFileDropList Method, ContainsImage Method, ContainsText Method, GetAudioStream Method, GetData Method, GetDataObject Method, GetFileDropList Method, GetImage Method, GetText Method, SetAudio Method, SetData Method, SetDataObject Method,SetFileDropList Method, SetImage Method, SetText Method
Clock Object
♦ My.Computer.Clock
See
GmtTime Property, LocalTime Property, TickCount Property
CombinePath Method
♦ My.Computer.FileSystem.CombinePath
Combines an absolute path, such as a directory, with an additional relative path, such as a file name, adding the appropriate punctuation.
VISUAL BASIC
Dim result As String = My.Computer.FileSystem.CombinePath(
"C:\temp", "OutputFile.txt")
C#
string result = System.IO.Path.Combine(
"C:\\temp", "OutputFile.txt");
CommandLineArgs Property
♦ My.Application.CommandLineArgs
Returns a collection of the command-line arguments used to initiate the application. The application path is not included as the first element; only the arguments themselves are included, if any.
VISUAL BASIC
' ----- This code returns a read-only collection of
' the command-line arguments, excluding the
' program itself.
Dim result As System.Collections.ObjectModel.
ReadOnlyCollection(Of String) =
My.Application.CommandLineArgs
C#
// ----- This code returns an ordinary string array of
// the command-line arguments, *including* the
// program itself as the zeroth array element.
string[] result = System.Environment.GetCommandLineArgs();
CompanyName Property
♦ My.Application.Info.CompanyName
Returns the company name as stored in the assembly.
VISUAL BASIC
Dim result As String = My.Application.Info.CompanyName
C#
string result;
System.Reflection.Assembly currentAssembly =
System.Reflection.Assembly.GetEntryAssembly();
if (currentAssembly == null) currentAssembly =
System.Reflection.Assembly.GetCallingAssembly();
object[] attrSet = currentAssembly.GetCustomAttributes(
typeof(System.Reflection.AssemblyCompanyAttribute),
inherit:true);
if (attrSet.Length == 0)
result = "";
else
result = ((System.Reflection.AssemblyCompanyAttribute)
attrSet[0]).Company;
Computer Object
♦ My.Computer
See
Audio Object, Clipboard Object, Clock Object, FileSystem Object, Info Object (My.Computer), Keyboard Object, Mouse Object, Name Property (My.Computer), Network Object, Ports Object, Registry Object, Screen Property
ContainsAudio Method
♦ My.Computer.Clipboard.ContainsAudio
Indicates whether the system clipboard contains audio data.
VISUAL BASIC
Dim result As Boolean =
My.Computer.Clipboard.ContainsAudio()
C#
// ----- For Windows Forms code:
bool result =
System.Windows.Forms.Clipboard.ContainsAudio();
// ----- For XAML-centric code:
bool result = System.Windows.Clipboard.ContainsAudio();
ContainsData Method
♦ My.Computer.Clipboard.ContainsData
Indicates whether the system clipboard contains content with a specific data format.
VISUAL BASIC
Dim result As Boolean = My.Computer.Clipboard.ContainsData(
"CustomerRecord")
C#
// ----- For Windows Forms code:
bool result = System.Windows.Forms.Clipboard.ContainsData(
"CustomerRecord");
// ----- For XAML-centric code:
bool result = System.Windows.Clipboard.ContainsData(
"CustomerRecord");
ContainsFileDropList Method
♦ My.Computer.Clipboard.ContainsFileDropList
Indicates whether the system clipboard contains a list of target file paths.
VISUAL BASIC
Dim result As Boolean = My.Computer.Clipboard.
ContainsFileDropList()
C#
// ----- For Windows Forms code:
bool result = System.Windows.Forms.Clipboard.
ContainsFileDropList();
// ----- For XAML-centric code:
bool result =
System.Windows.Clipboard.ContainsFileDropList();
ContainsImage Method
♦ My.Computer.Clipboard.ContainsImage
Indicates whether the system clipboard contains image data.
VISUAL BASIC
Dim result As Boolean =
My.Computer.Clipboard.ContainsImage()
C#
// ----- For Windows Forms code:
bool result =
System.Windows.Forms.Clipboard.ContainsImage();
// ----- For XAML-centric code:
bool result = System.Windows.Clipboard.ContainsImage();
ContainsText Method
♦ My.Computer.Clipboard.ContainsText
Indicates whether the system clipboard contains text, optionally in a specified format.
VISUAL BASIC
Dim result As Boolean =
My.Computer.Clipboard.ContainsText()
C#
// ----- For Windows Forms code:
bool result =
System.Windows.Forms.Clipboard.ContainsText();
// ----- For XAML-centric code:
bool result = System.Windows.Clipboard.ContainsText();
The ContainsText method accepts one optional argument that indicates the type of text to check, such as HTML or Unicode. In the My and Windows Forms versions of the code, this argument is of type System.Windows.Forms.TextDataFormat; for XAML code, use the System.Windows.TextDataFormat enumeration instead.
CopyDirectory Method
♦ My.Computer.FileSystem.CopyDirectory
Copies a directory and all files within it to a new destination directory.
VISUAL BASIC
' ----- Basic syntax. Third (optional) argument is
' the overwrite flag.
My.Computer.FileSystem.CopyDirectory(
source, destination, True)
' ----- UI-invoking syntax.
My.Computer.FileSystem.CopyDirectory(source, destination,
UIOption.OnlyErrorDialogs)
C# does not include a feature that will copy a complete directory. For basic directory copy operations, your code must manually create the target directory and copy each file and subdirectory within the source directory to the target using features in the System.IOnamespace.
C#
private void CopyDirectory(string source,
string destination)
{
string destItem;
// ----- Create the target directory.
System.IO.Directory.CreateDirectory(destination);
// ----- Scan each source file.
foreach (string oneFile in System.IO.
Directory.GetFiles(source))
{
// ----- Copy a file to the target.
destItem = System.IO.Path.Combine(destination,
System.IO.Path.GetFileName(oneFile));
System.IO.File.Copy(oneFile, destItem);
}
// ----- Scan each source subdirectory.
foreach (string oneDirectory in System.IO.
Directory.GetDirectories(source))
{
// ----- Recurse to copy the subdirectory.
destItem = System.IO.Path.Combine(destination,
System.IO.Path.GetFileName(oneDirectory));
CopyDirectory(oneDirectory, destItem);
}
}
C# does not include features that invoke the Windows directory copy dialog. Instead, you must access the Win32 API directly and call the appropriate function. In the case of directory copying and similar file-based actions, you call the SHFileOperation API. See the “CopyFile Method” entry in this chapter for sample code that calls this API.
CopyFile Method
♦ My.Computer.FileSystem.CopyFile
Copies a file to a new location.
VISUAL BASIC
' ----- Basic syntax. Third (optional) argument is
' the overwrite flag.
My.Computer.FileSystem.CopyFile(source, destination, True)
' ----- UI-invoking syntax.
My.Computer.FileSystem.CopyFile(source, destination,
UIOption.OnlyErrorDialogs)
For basic file copy operations, the File.Copy method in the System.IO namespace provides functionality similar to the basic VB syntax.
C#
// ----- Third argument is the "overwrite" flag.
System.IO.File.Copy(source, destination, true);
C# does not include features that invoke the Windows file copy dialog. Instead, you must access the Win32 API directly and call the appropriate function. In the case of file copying and similar file-based actions, you call the SHFileOperation API. The following code shows how to call this method to perform a basic file copy.
C#
using System;
using System.Runtime.InteropServices;
public class FileCopy
{
// ----- Type of shell operation.
private enum FileFuncFlags : uint
{
FO_MOVE = 0x1,
FO_COPY = 0x2,
FO_DELETE = 0x3,
FO_RENAME = 0x4
}
// ----- Additional flags for some operations.
[Flags] public enum FileOpFlags : ushort
{
FOF_MULTIDESTFILES = 0x1,
FOF_CONFIRMMOUSE = 0x2,
FOF_SILENT = 0x4,
FOF_RENAMEONCOLLISION = 0x8,
FOF_NOCONFIRMATION = 0x10,
FOF_WANTMAPPINGHANDLE = 0x20,
FOF_ALLOWUNDO = 0x40,
FOF_FILESONLY = 0x80,
FOF_SIMPLEPROGRESS = 0x100,
FOF_NOCONFIRMMKDIR = 0x200,
FOF_NOERRORUI = 0x400,
FOF_NOCOPYSECURITYATTRIBS = 0x800,
FOF_NORECURSION = 0x1000,
FOF_NO_CONNECTED_ELEMENTS = 0x2000,
FOF_WANTNUKEWARNING = 0x4000,
FOF_NORECURSEREPARSE = 0x8000
}
// ----- Structure for operation details.
[StructLayout(LayoutKind.Sequential,
CharSet=CharSet.Unicode)]
private struct SHFILEOPSTRUCT
{
public IntPtr hwnd;
public FileFuncFlags wFunc;
[MarshalAs(UnmanagedType.LPWStr)]
public string pFrom;
[MarshalAs(UnmanagedType.LPWStr)]
public string pTo;
public FileOpFlags fFlags;
[MarshalAs(UnmanagedType.Bool)]
public bool fAnyOperationsAborted;
public IntPtr hNameMappings;
[MarshalAs(UnmanagedType.LPWStr)]
public string lpszProgressTitle;
}
// ----- Main shell file operation method.
[DllImport("shell32.dll",CharSet = CharSet.Unicode)]
static extern int SHFileOperation(
[In] ref SHFILEOPSTRUCT lpFileOp);
public static void CopyFiles(
string sourceFile, string destination)
{
// ----- Copy a file using the Windows copy.
SHFILEOPSTRUCT fileDetail;
int result;
fileDetail.wFunc = FileFuncFlags.FO_COPY;
fileDetail.fFlags = FileOpFlags.FOF_ALLOWUNDO;
fileDetail.pFrom = sourceFile + "\0\0";
fileDetail.pTo = destination + "\0\0";
fileDetail.hwnd = IntPtr.Zero;
fileDetail.fAnyOperationsAborted = false;
fileDetail.hNameMappings = IntPtr.Zero;
fileDetail.lpszProgressTitle = "";
try
{
result = SHFileOperation(ref fileDetail);
if (result != 0)
System.Windows.Forms.MessageBox.Show(
"Error occurred during copy.");
}
catch (Exception ex)
{
System.Windows.Forms.MessageBox.Show(
ex.Message);
}
}
}
Microsoft’s MSDN web site (msdn.microsoft.com) includes full documentation on this and other “shell” features.
Copyright Property
♦ My.Application.Info.Copyright
Returns the copyright owner notice as stored in the assembly.
VISUAL BASIC
Dim result As String = My.Application.Info.Copyright
C#
string result;
System.Reflection.Assembly currentAssembly =
System.Reflection.Assembly.GetEntryAssembly();
if (currentAssembly == null) currentAssembly =
System.Reflection.Assembly.GetCallingAssembly();
object[] attrSet = currentAssembly.GetCustomAttributes(
typeof(System.Reflection.AssemblyCopyrightAttribute),
inherit:true);
if (attrSet.Length == 0)
result = "";
else
result = ((System.Reflection.
AssemblyCopyrightAttribute)attrSet[0]).Copyright;
CreateDirectory Method
♦ My.Computer.FileSystem.CreateDirectory
Creates the directory and subdirectories in a path.
VISUAL BASIC
My.Computer.FileSystem.CreateDirectory("C:\temp")
C#
System.IO.Directory.CreateDirectory("C:\\temp");
CtrlKeyDown Property
♦ My.Computer.Keyboard.CtrlKeyDown
Indicates whether a Control key is currently pressed.
VISUAL BASIC
Dim result As Boolean = My.Computer.Keyboard.CtrlKeyDown
C#
// ----- For Windows Forms code:
bool result = ((System.Windows.Forms.Control.ModifierKeys &
System.Windows.Forms.Keys.Control) != 0);
// ----- For XAML-centric code:
bool result = ((System.Windows.Input.Keyboard.Modifiers &
System.Windows.Input.ModifierKeys.Control) != 0);
Culture Property
♦ My.Application.Culture
Returns an object that describes the active data-formatting culture for numbers, dates, and other values.
VISUAL BASIC
Dim result As System.Globalization.CultureInfo =
My.Application.Culture
C#
System.Globalization.CultureInfo result =
System.Threading.Thread.CurrentThread.CurrentCulture;
CurrentConfig Property
♦ My.Computer.Registry.CurrentConfig
Returns a reference to the HKEY_CURRENT_CONFIG Windows registry location.
VISUAL BASIC
Dim result As Microsoft.Win32.RegistryKey =
My.Computer.Registry.CurrentConfig
C#
Microsoft.Win32.RegistryKey result =
Microsoft.Win32.Registry.CurrentConfig;
CurrentDirectory Property
♦ My.Computer.FileSystem.CurrentDirectory
Returns the full path to the directory used for relative directory references.
VISUAL BASIC
Dim result As String =
My.Computer.FileSystem.CurrentDirectory
C#
string result = System.IO.Directory.GetCurrentDirectory();
CurrentPrincipal Property
♦ My.User.CurrentPrincipal
Returns the in-effect security context.
VISUAL BASIC
Dim result As System.Security.Principal.IPrincipal =
My.User.CurrentPrincipal
C#
System.Security.Principal.IPrincipal result =
System.Threading.Thread.CurrentPrincipal;
CurrentUser Property
♦ My.Computer.Registry.CurrentUser
Returns a reference to the HKEY_CURRENT_USER Windows registry location.
VISUAL BASIC
Dim result As Microsoft.Win32.RegistryKey =
My.Computer.Registry.CurrentUser
C#
Microsoft.Win32.RegistryKey result =
Microsoft.Win32.Registry.CurrentUser;
CurrentUserApplicationData Property
♦ My.Computer.FileSystem.SpecialDirectories.CurrentUserApplicationData
Returns the path to the “application data” folder for the current user.
VISUAL BASIC
Dim result As String = My.Computer.FileSystem.
SpecialDirectories.CurrentUserApplicationData
C#
string result = System.Environment.GetFolderPath(
System.Environment.SpecialFolder.ApplicationData);
DefaultFileLogWriter Property
♦ My.Application.Log.DefaultFileLogWriter (for Desktop applications)
♦ My.Log.DefaultFileLogWriter (for ASP.NET applications)
C# applications do not configure logging features by default. Therefore, there is no default listener for logging purposes.
See Also
TraceSource Property
DeleteDirectory Method
♦ My.Computer.FileSystem.DeleteDirectory
Deletes a directory or moves it to the Recycle Bin.
VISUAL BASIC
' ----- Basic syntax. Directory is deleted permanently.
My.Computer.FileSystem.DeleteDirectory(targetDirectory,
DeleteDirectoryOption.DeleteAllContents)
' ----- UI-invoking syntax.
My.Computer.FileSystem.DeleteDirectory(targetDirectory,
UIOption.OnlyErrorDialogs,
RecycleOption.SendToRecycleBin)
For basic directory delete operations, the Directory.Delete method in the System.IO namespace provides functionality comparable to the basic VB syntax.
C#
// ----- Directory is deleted permanently. The
// second argument deletes even when the
// target is not empty.
System.IO.Directory.Delete(targetFile, true);
C# does not include features that invoke the Windows directory delete dialog. Instead, you must access the Win32 API directly and call the appropriate function. In the case of directory removal and similar file-based actions, you call the SHFileOperation API. See the “CopyFile Method” entry in this chapter for sample code that calls this API.
DeleteFile Method
♦ My.Computer.FileSystem.DeleteFile
Deletes a file or moves it to the Recycle Bin.
VISUAL BASIC
' ----- Basic syntax. File is deleted permanently.
My.Computer.FileSystem.DeleteFile(targetFile)
' ----- UI-invoking syntax.
My.Computer.FileSystem.DeleteFile(targetFile,
UIOption.OnlyErrorDialogs,
RecycleOption.SendToRecycleBin)
For basic file delete operations, the File.Delete method in the System.IO namespace provides functionality comparable to the basic VB syntax.
C#
// ----- File is deleted permanently.
System.IO.File.Delete(targetFile);
C# does not include features that invoke the Windows file delete dialog. Instead, you must access the Win32 API directly and call the appropriate function. In the case of file removal and similar file-based actions, you call the SHFileOperation API. See the “CopyFile Method” entry in this chapter for sample code that calls this API.
Deployment Property
♦ My.Application.Deployment
Returns the current application’s ClickOnce (installation) deployment object.
VISUAL BASIC
Dim result As System.Deployment.Application.
ApplicationDeployment = My.Application.Deployment
C#
System.Deployment.Application.ApplicationDeployment
result = System.Deployment.Application.
ApplicationDeployment.CurrentDeployment;
Description Property
♦ My.Application.Info.Description
Returns the application description as stored in the assembly.
VISUAL BASIC
Dim result As String = My.Application.Info.Description
C#
string result;
System.Reflection.Assembly currentAssembly =
System.Reflection.Assembly.GetEntryAssembly();
if (currentAssembly == null) currentAssembly =
System.Reflection.Assembly.GetCallingAssembly();
object[] attrSet = currentAssembly.GetCustomAttributes(
typeof(System.Reflection.AssemblyDescriptionAttribute),
inherit:true);
if (attrSet.Length == 0)
result = "";
else
result = ((System.Reflection.
AssemblyDescriptionAttribute)
attrSet[0]).Description;
Desktop Property
♦ My.Computer.FileSystem.SpecialDirectories.Desktop
Returns the path to the “desktop” folder for the current user.
VISUAL BASIC
Dim result As String = My.Computer.FileSystem.
SpecialDirectories.Desktop
C#
string result = System.Environment.GetFolderPath(
System.Environment.SpecialFolder.DesktopDirectory);
DirectoryExists Method
♦ My.Computer.FileSystem.DirectoryExists
Indicates whether a directory path exists.
VISUAL BASIC
Dim result As Boolean = My.Computer.FileSystem.
DirectoryExists("C:\temp")
C#
bool result = System.IO.Directory.Exists("C:\\temp");
DirectoryPath Property
♦ My.Application.Info.DirectoryPath
Returns the path for the directory containing the current application.
VISUAL BASIC
Dim result As String = My.Application.Info.DirectoryPath
C#
System.Reflection.Assembly currentAssembly =
System.Reflection.Assembly.GetEntryAssembly();
if (currentAssembly == null) currentAssembly =
System.Reflection.Assembly.GetCallingAssembly();
string result = System.IO.Path.GetDirectoryName(
currentAssembly.Location);
DoEvents Method
♦ My.Application.DoEvents
In Windows Forms applications, temporarily suspends the current code to allow processing of messages in other threads and processes.
VISUAL BASIC
My.Application.DoEvents()
C#
// ----- For Windows Forms code only:
System.Windows.Forms.Application.DoEvents();
XAML-based applications use a “dispatcher” or a “background worker thread” to achieve this same purpose.
DownloadFile Method
♦ My.Computer.Network.DownloadFile
Downloads a file from a network address to the local computer.
VISUAL BASIC
My.Computer.Network.DownloadFile(sourceAddress,
destinationFile, userName, password);
C#
System.Net.WebClient client = new System.Net.WebClient();
System.Uri sourceUri = new System.Uri(sourceAddress);
// ----- Default credentials.
client.UseDefaultCredentials = true;
// ----- Or, supply specific credentials.
client.UseDefaultCredentials = false;
client.Credentials = new System.Net.NetworkCredential(
userName, password);
// ----- Synchronous copy.
client.DownloadFile(sourceUri, destinationFile);
// ----- Or, asynchronous copy, providing your own
// custom complete/cancel event handler.
client.DownloadFileCompleted += new
AsyncCompletedEventHandler(CompletedCallback);
client.DownloadFileAsync(sourceUri, destinationFile);
The WebClient class’ download methods will overwrite the target file if it exists. You must manually check for the file if you do not want it overwritten. Also, it provides no visual cues as to the state of the transfer. You must provide your own progress dialog if desired.
To override the default timeout value, derive a new class from the WebClient class, and manually configure the WebRequest’s TimeOut property. Then use this class instead of the standard WebClient class to perform the download.
C#
class WebClientTimeout : System.Net.WebClient
{
public int Timeout { get; set; }
public WebClientTimeout(int timeoutOverride)
{
// ----- Save the user-specified timeout.
this.Timeout = timeoutOverride;
}
protected override System.Net.WebRequest
GetWebRequest(System.Uri sourceAddress)
{
// ----- Modify the request with the timeout.
System.Net.WebRequest coreRequest =
base.GetWebRequest(sourceAddress);
if (coreRequest != null)
coreRequest.Timeout = this.Timeout;
return coreRequest;
}
}
Drives Property
♦ My.Computer.FileSystem.Drives
Returns a collection of objects describing the workstation’s logical disk drives.
VISUAL BASIC
' ----- This code returns a read-only collection of drives.
Dim result As System.Collections.ObjectModel.
ReadOnlyCollection(Of System.IO.DriveInfo) =
My.Computer.FileSystem.Drives
C#
// ----- This code returns an ordinary array of drives.
System.IO.DriveInfo[] result =
System.IO.DriveInfo.GetDrives();
DynData Property
♦ My.Computer.Registry.DynData
Returns a reference to the HKEY_DYN_DATA Windows registry location.
VISUAL BASIC
' ----- This code is obsolete.
Dim result As Microsoft.Win32.RegistryKey =
My.Computer.Registry.DynData
C#
// ----- This code is obsolete.
Microsoft.Win32.RegistryKey result =
Microsoft.Win32.Registry.DynData;
This code is useful only on Windows 98 and Windows ME platforms. It is not valid on Windows NT-based systems or later.
FileExists Method
♦ My.Computer.FileSystem.FileExists
Indicates whether a file path exists.
VISUAL BASIC
Dim result As Boolean = My.Computer.FileSystem.FileExists(
"C:\temp\WorkFile.txt")
C#
bool result = System.IO.File.Exists(
"C:\\temp\\WorkFile.txt");
FileSystem Object
♦ My.Computer.FileSystem
See
CombinePath Method, CopyDirectory Method, CopyFile Method, CreateDirectory Method, CurrentDirectory Property, DeleteDirectory Method, DeleteFile Method, DirectoryExists Method, Drives Property, FileExists Method, FindInFiles Method, GetDirectories Method, GetDirectoryInfo Method, GetDriveInfo Method, GetFileInfo Method, GetFiles Method, GetName Method, GetParentPath Method, GetTempFileName Method, MoveDirectory Method, MoveFile Method, OpenTextFieldParser Method, OpenTextFileReader Method, OpenTextFileWriter Method, ReadAllBytes Method, ReadAllText Method, RenameDirectory Method, RenameFile Method, SpecialDirectories Object, WriteAllBytes Method, WriteAllText Method
FindInFiles Method
♦ My.Computer.FileSystem.FindInFiles
Returns a collection of file paths from a target directory that contains a specified search string.
VISUAL BASIC
Dim result As System.Collections.ObjectModel.
ReadOnlyCollection(Of String) =
My.Computer.FileSystem.FindInFiles(targetDirectory,
searchText, ignoreCase,
SearchOption.SearchAllSubDirectories, "*.txt")
C# does not include an equivalent for VB’s FindInFiles method. Instead, you must examine each file in a target directory to see if it contains the search string. The following code provides one example of how you can search for matches.
C#
private static List<string> FindInFiles(
string targetDirectory, string searchText,
bool ignoreCase, System.IO.SearchOption depthType,
string fileMask = "*.*")
{
List<string> results = new List<string>();
bool foundMatch;
string content;
foreach (string oneFile
in System.IO.Directory.GetFiles(
targetDirectory, fileMask, depthType))
{
// ----- WARNING: Large files could fill memory.
content = System.IO.File.ReadAllText(oneFile);
if (ignoreCase)
foundMatch = content.ToUpper().Contains(
searchText.ToUpper());
else
foundMatch = content.Contains(searchText);
if (foundMatch)
results.Add(oneFile);
}
return results;
}
Forms Object
♦ My.Forms
Provides access to any form within the current Windows Forms project.
VISUAL BASIC
' ----- Full syntax
My.Forms.Form1.Show()
' ----- Shortened syntax
Form1.Show()
Windows Forms applications written in C# do not maintain a list of the current active or available forms within the project. Each form must be manually instantiated, and any monitoring of all active forms must be done through custom code.
GetAudioStream Method
♦ My.Computer.Clipboard.GetAudioStream
Returns a stream object of audio data from the system clipboard.
VISUAL BASIC
Dim result As System.IO.Stream =
My.Computer.Clipboard.GetAudioStream()
C#
// ----- For Windows Forms code:
System.IO.Stream result = System.Windows.Forms.
Clipboard.GetAudioStream();
// ----- For XAML-centric code:
System.IO.Stream result = System.Windows.
Clipboard.GetAudioStream();
GetData Method
♦ My.Computer.Clipboard.GetData
Returns an object from the system clipboard in the specified format.
VISUAL BASIC
Dim result As Object = My.Computer.Clipboard.
GetData("MyAppFormat")
C#
// ----- For Windows Forms code:
object result = System.Windows.Forms.Clipboard.
GetData("MyAppFormat");
// ----- For XAML-centric code:
object result = System.Windows.Clipboard.
GetData("MyAppFormat");
GetDataObject Method
♦ My.Computer.Clipboard.GetDataObject
Returns an object from the system clipboard that supports the IDataObject interface. When the clipboard contains data in multiple formats at once, this interface provides access to each of those formats.
VISUAL BASIC
Dim result As System.Windows.Forms.IDataObject =
My.Computer.Clipboard.GetDataObject()
C#
// ----- For Windows Forms code:
System.Windows.Forms.IDataObject result =
System.Windows.Forms.Clipboard.GetDataObject();
// ----- For XAML-centric code:
System.Windows.IDataObject result =
System.Windows.Clipboard.GetDataObject();
GetDirectories Method
♦ My.Computer.FileSystem.GetDirectories
Returns a collection of directory names in a specified directory, optionally checking in subdirectories, and optionally matching a pattern.
VISUAL BASIC
' ----- Return directories starting with "A" in
' the target directory, ignore subdirectories.
Dim result As ReadOnlyCollection(Of String) =
My.Computer.FileSystem.GetDirectories(
"C:\WorkArea", SearchOption.SearchTopLevelOnly, "A*")
C#
// ----- Return directories starting with "A" in
// the target directory, ignore subdirectories.
string[] result = System.IO.Directory.GetDirectories(
"C:\\WorkArea", "A*",
System.IO.SearchOption.TopDirectoryOnly);
As shown in this sample code, the C# equivalent returns an array of strings instead of a collection.
GetDirectoryInfo Method
♦ My.Computer.FileSystem.GetDirectoryInfo
Returns an informational object for the indicated directory.
VISUAL BASIC
Dim result As System.IO.DirectoryInfo =
My.Computer.FileSystem.GetDirectoryInfo("C:\temp")
C#
System.IO.DirectoryInfo result =
new System.IO.DirectoryInfo("C:\\temp");
GetDriveInfo Method
♦ My.Computer.FileSystem.GetDriveInfo
Returns an informational object for the indicated drive letter.
VISUAL BASIC
Dim result As System.IO.DriveInfo =
My.Computer.FileSystem.GetDriveInfo("C:")
C#
System.IO.DriveInfo result = new System.IO.DriveInfo("C:");
GetEnvironmentVariable Method
♦ My.Application.GetEnvironmentVariable
Retrieves the value of the specified Windows environment variable.
VISUAL BASIC
' ----- Throws an exception if the variable is not found.
Dim result As String =
My.Application.GetEnvironmentVariable("PATH")
C#
// ----- Returns null if the variable is not found.
string result = System.Environment.
GetEnvironmentVariable("PATH");
GetFileDropList Method
♦ My.Computer.Clipboard.GetFileDropList
Returns a collection of file-path strings from the system clipboard.
VISUAL BASIC
Dim result As System.Collections.
Specialized.StringCollection =
My.Computer.Clipboard.GetFileDropList()
C#
// ----- For Windows Forms code:
System.Collections.Specialized.StringCollection result =
System.Windows.Forms.Clipboard.GetFileDropList();
// ----- For XAML-centric code:
System.Collections.Specialized.StringCollection result =
System.Windows.Clipboard.GetFileDropList();
GetFileInfo Method
♦ My.Computer.FileSystem.GetFileInfo
Returns an informational object for the indicated file.
VISUAL BASIC
Dim result As System.IO.FileInfo =
My.Computer.FileSystem.GetFileInfo(
"C:\temp\WorkFile.txt")
C#
System.IO.FileInfo result =
new System.IO.FileInfo("C:\\temp\\WorkFile.txt");
GetFiles Method
♦ My.Computer.FileSystem.GetFiles
Returns a collection of file names in a specified directory, optionally checking in subdirectories, and optionally matching a pattern.
VISUAL BASIC
' ----- Return text files with a .txt extension in
' the target directory, ignore subdirectories.
Dim result As ReadOnlyCollection(Of String) =
My.Computer.FileSystem.GetFiles("C:\WorkArea",
SearchOption.SearchTopLevelOnly, "*.txt")
C#
// ----- Return text files with a .txt extension in
// the target directory, ignore subdirectories.
string[] result =
System.IO.Directory.GetFiles("C:\\WorkArea", "*.txt",
System.IO.SearchOption.TopDirectoryOnly);
As shown in this sample code, the C# equivalent returns an array of strings instead of a collection.
GetImage Method
♦ My.Computer.Clipboard.GetImage
Returns an image from the system clipboard.
VISUAL BASIC
Dim result As System.Drawing.Image =
My.Computer.Clipboard.GetImage()
C#
// ----- For Windows Forms code:
System.Drawing.Image result =
System.Windows.Forms.Clipboard.GetImage();
// ----- For XAML-centric code:
System.Drawing.Image result =
System.Windows.Clipboard.GetImage();
GetName Method
♦ My.Computer.FileSystem.GetName
Returns the file name portion of a file path.
VISUAL BASIC
' ----- Returns "WorkFile.txt"
Dim result As String = My.Computer.FileSystem.GetName(
"C:\temp\WorkFile.txt")
C#
// ----- Returns "WorkFile.txt"
string result = System.IO.Path.GetFileName(
"C:\\temp\\WorkFile.txt");
GetParentPath Method
♦ My.Computer.FileSystem.GetParentPath
Returns the parent directory for a specified file or directory path.
VISUAL BASIC
' ----- Returns "C:\temp"
Dim result As String =
My.Computer.FileSystem.GetParentPath(
"C:\temp\WorkFile.txt")
C#
// ----- Returns "C:\temp"
string result = System.IO.Path.GetDirectoryName(
"C:\\temp\\WorkFile.txt");
GetParentPath accepts absolute or relative paths. The C# equivalent requires an absolute path.
GetTempFileName Method
♦ My.Computer.FileSystem.GetTempFileName
Creates a temporary file, and returns the path to that file.
VISUAL BASIC
Dim result As String =
My.Computer.FileSystem.GetTempFileName()
C#
string result = System.IO.Path.GetTempFileName();
GetText Method
♦ My.Computer.Clipboard.GetText
Returns text from the system clipboard.
VISUAL BASIC
Dim result As String = My.Computer.Clipboard.GetText()
C#
// ----- For Windows Forms code:
string result = System.Windows.Forms.Clipboard.GetText();
// ----- For XAML-centric code:
string result = System.Windows.Clipboard.GetText();
The GetText method accepts one optional argument that indicates the type of text to check, such as HTML or Unicode. In the My and Windows Forms versions of the code, this argument is of type System.Windows.Forms.TextDataFormat; for XAML code, use theSystem.Windows.TextDataFormat enumeration instead. By default, the text is retrieved in Unicode format.
GetValue Method
♦ My.Computer.Registry.GetValue
Returns data from a specified Windows registry value.
VISUAL BASIC
Dim result As Long = CLng(My.Computer.Registry.GetValue(
"HKEY_CURRENT_USER\Software\Example\MyApp",
"ErrorCount", 0&))
C#
long result = (long)Microsoft.Win32.Registry.GetValue(
"HKEY_CURRENT_USER\\Software\\Example\\MyApp",
"ErrorCount", 0L);
GmtTime Property
♦ My.Computer.Clock.GmtTime
Returns the current date and time in the UTC (Universal Coordinated Time) time zone.
VISUAL BASIC
Dim result As Date = My.Computer.Clock.GmtTime
C#
DateTime result = DateTime.UtcNow;
Info Object (My.Application)
♦ My.Application.Info
See
AssemblyName Property, CompanyName Property, Copyright Property, Description Property, DirectoryPath Property, LoadedAssemblies Property, ProductName Property, StackTrace Property, Title Property, Trademark Property, Version Property, WorkingSet Property
Info Object (My.Computer)
♦ My.Computer.Info
See
AvailablePhysicalMemory PropertyAvailableVirtualMemory Property, InstalledUICulture Property, OSFullName Property, OSPlatform Property, OSVersion Property, TotalPhysicalMemory Property, TotalVirtualMemory Property
InitializeWithWindowsUser Method
♦ My.User.InitializeWithWindowsUser
Resets My.User to refer to the user that started the application.
VISUAL BASIC
My.User.InitializeWithWindowsUser()
C#
System.Threading.Thread.CurrentPrincipal =
new System.Security.Principal.WindowsPrincipal(
System.Security.Principal.WindowsIdentity.GetCurrent);
InstalledUICulture Property
♦ My.Computer.Info.InstalledUICulture
Returns an object that describes the user interface culture of the operating system.
VISUAL BASIC
Dim result As System.Globalization.CultureInfo =
My.Computer.Info.InstalledUICulture
C#
System.Globalization.CultureInfo result =
System.Globalization.CultureInfo.InstalledUICulture;
IsAuthenticated Property
♦ My.User.IsAuthenticated
Returns a value indicating the authentication status of the current user.
VISUAL BASIC
Dim result As Boolean = My.User.IsAuthenticated
C#
bool result = System.Threading.Thread.
CurrentPrincipal.Identity.IsAuthenticated;
IsAvailable Property
♦ My.Computer.Network.IsAvailable
Indicates whether a network connected to the local computer is available for use.
VISUAL BASIC
Dim result As Boolean = My.Computer.Network.IsAvailable
C#
bool result = System.Net.NetworkInformation.
NetworkInterface.GetIsNetworkAvailable();
IsInRole Method
♦ My.User.IsInRole
Returns a value indicating whether the current user belongs to the specified role.
VISUAL BASIC
' Option 1: Dim role As String = "Administrator"
' Option 2: Dim role As BuiltInRole =
' BuiltInRole.Administrator
Dim result As Boolean = My.User.IsInRole(role)
C#
// ----- Option 1: String-based lookup.
string role = "Administrator";
bool result = System.Threading.Thread.
CurrentPrincipal.IsInRole(role);
// ----- Option 2: Windows role-based lookup.
// Assumes: using System.Security.Principal;
bool result;
WindowsBuiltInRole role = WindowsBuiltInRole.Administrator;
IPrincipal activePrincipal =
System.Threading.Thread.CurrentPrincipal;
if (activePrincipal is WindowsPrincipal)
result = ((WindowsPrincipal)activePrincipal).
IsInRole(role);
else
{
TypeConverter converter = TypeDescriptor.GetConverter(
typeof(WindowsBuiltInRole));
result = activePrincipal.IsInRole(
converter.ConvertToString(role));
}
The My namespace includes a BuiltInRole enumeration that is closely related to the WindowsBuiltInRole enumeration indicated in the sample code. The members are identical, so it is valid to use the Windows-specific version in C# code. To check role membership for Windows users, you can use either the string-based or enumeration-based versions. For non-Windows role verifications, use the string version only.
IsNetworkDeployed Property
♦ My.Application.IsNetworkDeployed
Returns a value that indicates whether the application was deployed from a network using ClickOnce.
VISUAL BASIC
Dim result As Boolean = My.Application.IsNetworkDeployed
C#
bool result = System.Deployment.Application.
ApplicationDeployment.IsNetworkDeployed;
Keyboard Object
♦ My.Computer.Keyboard
See
AltKeyDown PropertyCapsLock Property, CtrlKeyDown Property, NumLock Property, ScrollLock Property, SendKeys Method, ShiftKeyDown Property
LoadedAssemblies Property
♦ My.Application.Info.LoadedAssemblies
Returns a collection of the current application’s loaded assemblies.
VISUAL BASIC
' ----- Returns a read-only collection of the results.
Dim result As System.Collections.ObjectModel.
ReadOnlyCollection(Of System.Reflection.Assembly) =
My.Application.Info.LoadedAssemblies
C#
// ----- Returns a standard array of the results.
System.Reflection.Assembly[] result =
AppDomain.CurrentDomain.GetAssemblies();
LocalMachine Property
♦ My.Computer.Registry.LocalMachine
Returns a reference to the HKEY_LOCAL_MACHINE Windows registry location.
VISUAL BASIC
Dim result As Microsoft.Win32.RegistryKey =
My.Computer.Registry.LocalMachine
C#
Microsoft.Win32.RegistryKey result =
Microsoft.Win32.Registry.LocalMachine;
LocalTime Property
♦ My.Computer.Clock.LocalTime
Returns the current date and time within the current time zone.
VISUAL BASIC
Dim result As Date = My.Computer.Clock.LocalTime
C#
DateTime result = DateTime.Now;
Log Object
♦ My.Application.Log (for Desktop applications)
♦ My.Log (for ASP.NET applications)
See
DefaultFileLogWriter Property, TraceSource Property, WriteEntry Method, WriteException Method
MinimumSplashScreenDisplayTime Property
♦ My.Application.MinimumSplashScreenDisplayTime
Specifies the minimum time, in milliseconds, that the splash screen should appear.
VISUAL BASIC
' ----- Show for at least two seconds.
My.Application.MinimumSplashScreenDisplayTime = 2000
This property is part of Visual Basic’s Windows Forms Application Framework, a set of classes not included in C# projects. There is no direct C# equivalent for the MinimumSplashScreenDisplayTime property. Instead, you must manage the display of any splash screen in your application by hand. See the “SplashScreen Property” entry in this chapter for additional information.
See Also
SplashScreen Property
Mouse Object
♦ My.Computer.Mouse
See
ButtonsSwapped Property, WheelExists Property, WheelScrollLines Property
MoveDirectory Method
♦ My.Computer.FileSystem.MoveDirectory
Moves a directory to a new location.
VISUAL BASIC
' ----- Basic syntax. Third (optional) argument is
' the overwrite flag.
My.Computer.FileSystem.MoveDirectory(
source, destination, True)
' ----- UI-invoking syntax.
My.Computer.FileSystem.MoveDirectory(source, destination,
UIOption.OnlyErrorDialogs)
For basic directory move operations, the Directory.Move method in the System.IO namespace provides functionality comparable to the basic VB syntax.
C#
// ----- Directory.Move lacks the overwrite option.
System.IO.Directory.Move(source, destination);
C# does not include features that invoke the Windows directory move dialog. Instead, you must access the Win32 API directly and call the appropriate function. In the case of directory moving and similar file-based actions, you call the SHFileOperation API. See the “CopyFile Method” entry in this chapter for sample code that calls this API.
MoveFile Method
♦ My.Computer.FileSystem.MoveFile
Moves a file to a new directory.
VISUAL BASIC
' ----- Basic syntax. Third (optional) argument is
' the overwrite flag.
My.Computer.FileSystem.MoveFile(source, destination, True)
' ----- UI-invoking syntax.
My.Computer.FileSystem.MoveFile(source, destination,
UIOption.OnlyErrorDialogs)
For basic file move operations, the File.Move method in the System.IO namespace provides functionality comparable to the basic VB syntax.
C#
// ----- File.Move lacks the overwrite option.
System.IO.File.Move(source, destination);
C# does not include features that invoke the Windows file move dialog. Instead, you must access the Win32 API directly and call the appropriate function. In the case of file moving and similar file-based actions, you call the SHFileOperation API. See the “CopyFile Method” entry in this chapter for sample code that calls this API.
My Namespace
♦ My
See
Application Object, Computer Object, Forms Object, Log Object (My), Request Object, Resources Object, Response Object, Settings Object, User Object, WebServices Object
MyDocuments Property
♦ My.Computer.FileSystem.SpecialDirectories.MyDocuments
Returns the path to the “documents” folder for the current user.
VISUAL BASIC
Dim result As String = My.Computer.FileSystem.
SpecialDirectories.MyDocuments
C#
string result = System.Environment.GetFolderPath(
System.Environment.SpecialFolder.MyDocuments);
MyMusic Property
♦ My.Computer.FileSystem.SpecialDirectories.MyMusic
Returns the path to the “music” folder for the current user.
VISUAL BASIC
Dim result As String = My.Computer.FileSystem.
SpecialDirectories.MyMusic
C#
string result = System.Environment.GetFolderPath(
System.Environment.SpecialFolder.MyMusic);
MyPictures Property
♦ My.Computer.FileSystem.SpecialDirectories.MyPictures
Returns the path to the “pictures” folder for the current user.
VISUAL BASIC
Dim result As String = My.Computer.FileSystem.
SpecialDirectories.MyPictures
C#
string result = System.Environment.GetFolderPath(
System.Environment.SpecialFolder.MyPictures);
Name Property (My.Computer)
♦ My.Computer.Name
Returns the name of the local computer.
VISUAL BASIC
Dim result As String = My.Computer.Name
C#
string result = System.Environment.MachineName;
Name Property (My.User)
♦ My.User.Name
Returns the current Windows user name.
VISUAL BASIC
Dim result As String = My.User.Name
C#
string result = System.Threading.Thread.
CurrentPrincipal.Identity.Name;
Network Object
♦ My.Computer.Network
See
DownloadFile Method, IsAvailable Property, NetworkAvailabilityChanged Event (My.Computer.Network), Ping Method, UploadFile Method
NetworkAvailabilityChanged Event (My.Application)
♦ My.Application.NetworkAvailabilityChanged
This event is limited to Windows Forms applications. The same event as exposed through the My.Computer.Network class is identical in purpose, and is available to all application types. See that event’s entry for the C# equivalent for both VB events.
See Also
NetworkAvailabilityChanged Event (My.Computer.Network)
NetworkAvailabilityChanged Event (My.Computer.Network)
♦ My.Computer.Network.NetworkAvailabilityChanged
Calls an event handler when network availability changes.
VISUAL BASIC
' ----- Event handler logic.
Public Sub NetworkPresenceHandler(ByVal sender As Object,
ByVal e As NetworkAvailableEventArgs)
End Sub
' ----- Elsewhere, associating handler with event.
AddHandler My.Computer.Network.NetworkAvailabilityChanged,
AddressOf NetworkPresenceHandler
C#
// ----- Event handler logic.
public static void NetworkPresenceHandler(object sender,
System.Net.NetworkInformation.
NetworkAvailabilityEventArgs e)
{
}
// ----- Elsewhere, associating handler with event.
System.Net.NetworkInformation.NetworkChange
.NetworkAvailabilityChanged += NetworkPresenceHandler;
NumLock Property
♦ My.Computer.Keyboard.NumLock
Indicates whether the Num Lock key is currently activated.
VISUAL BASIC
Dim result As Boolean = My.Computer.Keyboard.NumLock
C#
// ----- For Windows Forms code:
bool result = System.Windows.Forms.Form.IsKeyLocked(
System.Windows.Forms.Keys.NumLock);
// ----- For XAML-centric code:
bool result = System.Windows.Input.Keyboard.IsKeyToggled(
System.Windows.Input.Key.NumLock);
OpenForms Property
♦ My.Application.OpenForms
Returns a collection of the forms currently open within a Windows Forms application.
VISUAL BASIC
Dim result As System.Windows.Forms.FormCollection =
My.Application.OpenForms
C#
System.Windows.Forms.FormCollection result =
System.Windows.Forms.Application.OpenForms;
OpenSerialPort Method
♦ My.Computer.Ports.OpenSerialPort
Opens a connection to a serial port on the local workstation.
VISUAL BASIC
Dim portAccess As System.IO.Ports.SerialPort =
My.Computer.Ports.OpenSerialPort(
portName, baudRate, parity, dataBits, stopBits)
C#
System.IO.Ports.SerialPort portAccess =
new System.IO.Ports.SerialPort(
portName, baudRate, parity, dataBits, stopBits);
OpenTextFieldParser Method
♦ My.Computer.FileSystem.OpenTextFieldParser
C# does not include a direct equivalent for the OpenTextFieldParser method, or the underlying TextFieldParser class that it employs. It is possible to add a reference to the Microsoft.VisualBasic assembly to a C# application and use these VB-targeted features. For applications that need to forgo access to all Visual Basic components, the equivalent functionality will need to be obtained from another source, or developed from scratch.
To open a file for reading in C#, open it as a stream using the appropriate encoding. Once opened, each line can be read in using the StreamReader class’ ReadLine method.
C#
string filePath = "C:\\temp\\FileWithFields.txt";
System.Text.Encoding useEncoding =
System.Text.Encoding.UTF8;
bool autoDetectEncoding = true;
System.IO.StreamReader inStream =
new System.IO.StreamReader(
filePath, useEncoding, autoDetectEncoding);
// ----- Later, in a loop.
string lineContent = inStream.ReadLine();
For fixed-width fields, extract specific portions of the line text.
C#
// ----- Line begins with a 2-character state followed
// by a 30-character city name.
string stateShort = lineContent.Substring(0, 2);
string cityName = lineContent.Substring(2, 30).Trim();
For delimited files that do not use text qualifiers around individual columns, use the string object’s Split method to get the individual fields.
C#
// ----- A tab-delimited file.
string[] allFields = lineContent.Split(new char[] {'\t'});
string stateShort = allFields[0];
string cityName = allFields[1];
For delimited files that include text qualifiers, with the optional inclusion of the delimiter within the quoted fields, you will need to process the characters of the line individually, or use some complex regular expressions that may vary based on the format of the input. The following code represents one way to parse the data, looking for quote-qualified comma-delimited strings.
C#
List<string> results = new List<string>();
int fieldPos = 0;
bool inQuote = false;
string tempField = "";
for (int counter = 0; counter < lineContent.Length;
counter++)
{
if (lineContent[counter] == ',')
{
// ----- Might be a new field or within quotes.
if (!inQuote)
{
// ----- Finished a field.
tempField = lineContent.Substring(
fieldPos, counter - fieldPos);
if ((tempField.Length >= 2) &&
(tempField.Substring(0, 1) == "\"") &&
(tempField.Substring(
tempField.Length - 1, 1) == "\""))
tempField = tempField.Substring(
1, tempField.Length - 2);
results.Add(tempField);
fieldPos = counter + 1;
}
}
else if (lineContent[counter] == '"')
{
// ----- Start or end a quoted field.
inQuote = !inQuote;
}
}
// ----- Finish the last field.
tempField = "";
if (lineContent.Length > fieldPos)
tempField = lineContent.Substring(fieldPos,
lineContent.Length - fieldPos);
if ((tempField.Length >= 2) &&
(tempField.Substring(0, 1) == "\"") &&
(tempField.Substring(
tempField.Length - 1, 1) == "\""))
tempField = tempField.Substring(1,
tempField.Length - 2);
results.Add(tempField);
string[] lineFields = results.ToArray();
This code does not handle all complex cases. For example, if a quoted field is surrounded by whitespace, the quotation marks will not be removed.
OpenTextFileReader Method
♦ My.Computer.FileSystem.OpenTextFileReader
Opens an existing file for text input.
VISUAL BASIC
Dim filePath As String = "C:\temp\WorkFile.txt"
Dim useEncoding As System.Text.Encoding =
System.Text.Encoding.UTF8
Dim result As System.IO.StreamReader =
My.Computer.FileSystem.OpenTextFileReader(
filePath, useEncoding)
C#
string filePath = "C:\\temp\\WorkFile.txt";
System.TextEncoding useEncoding =
System.Text.Encoding.UTF8;
bool autoDetectEncoding = true;
System.IO.StreamReader result = new System.IO.StreamReader(
filePath, useEncoding, autoDetectEncoding);
In Visual Basic, the encoding parameter is optional; when absent, output defaults to UTF8 encoding. The equivalent StreamReader class accepts a wider variety of parameter options in its constructor. See the Visual Studio documentation for these options.
OpenTextFileWriter Method
♦ My.Computer.FileSystem.OpenTextFileWriter
Opens an existing file, or creates a new one, for text output.
VISUAL BASIC
Dim filePath As String = "C:\temp\WorkFile.txt"
Dim appendIfFound As Boolean = True
Dim useEncoding As System.Text.Encoding =
System.Text.Encoding.UTF8
Dim result As System.IO.StreamWriter =
My.Computer.FileSystem.OpenTextFileWriter(
filePath, appendIfFound, useEncoding)
C#
string filePath = "C:\\temp\\WorkFile.txt";
bool appendIfFound = true;
System.TextEncoding useEncoding =
System.Text.Encoding.UTF8;
System.IO.StreamWriter result = new System.IO.StreamWriter(
filePath, appendIfFound, useEncoding);
In Visual Basic, the encoding parameter is optional; when absent, output defaults to UTF8 encoding. The equivalent StreamWriter class accepts a wider variety of parameter options in its constructor. See the Visual Studio documentation for these options.
OSFullName Property
♦ My.Computer.Info.OSFullName
Returns the full name of the operating system.
VISUAL BASIC
Dim result As String = My.Computer.Info.OSFullName
C#
// Assumes: using System.Management;
// ----- Default to My.Computer.Info.OSPlatform equivalent.
string result =
System.Environment.OSVersion.Platform.ToString();
try
{
SelectQuery querySet =
new SelectQuery("Win32_OperatingSystem");
ManagementObjectSearcher queryScan =
new ManagementObjectSearcher(querySet);
ManagementObjectCollection results = queryScan.Get();
if (results.Count > 0)
{
ManagementObjectCollection.
ManagementObjectEnumerator
resultsEnumerator = results.GetEnumerator();
resultsEnumerator.MoveNext();
result = (string)resultsEnumerator.Current.
Properties["Name"].Value;
if (result.Contains('|') == true)
result = result.Substring(0,
result.IndexOf('|'));
}
} catch { }
OSPlatform Property
♦ My.Computer.Info.OSPlatform
Returns the platform name of the operating system.
VISUAL BASIC
Dim result As String = My.Computer.Info.OSPlatform
C#
string result = System.Environment.
OSVersion.Platform.ToString();
OSVersion Property
♦ My.Computer.Info.OSVersion
Returns the version number of the operating system.
VISUAL BASIC
Dim result As String = My.Computer.Info.OSVersion
C#
string result = System.Environment.
OSVersion.Version.ToString();
PerformanceData Property
♦ My.Computer.Registry.PerformanceData
Returns a reference to the HKEY_PERFORMANCE_DATA Windows registry location.
VISUAL BASIC
Dim result As Microsoft.Win32.RegistryKey =
My.Computer.Registry.PerformanceData
C#
Microsoft.Win32.RegistryKey result =
Microsoft.Win32.Registry.PerformanceData;
Ping Method
♦ My.Computer.Network.Ping
Tests for the presence of another computer or device on a network by issuing an ICMP protocol echo request.
VISUAL BASIC
' ----- Using string host or IP address, default timeout.
Dim result As Boolean = My.Computer.Network.Ping(
"www.example.com")
' ----- Using Uri host, specific timeout.
Dim target As New System.Uri("http://www.example.com")
Dim result As Boolean = My.Computer.Network.Ping(
target, 3000)
C#
// ----- Using string host or IP address, default timeout.
bool result = ((new System.Net.NetworkInformation.Ping())
.Send("www.example.com").Status ==
System.Net.NetworkInformation.IPStatus.Success);
// ----- Using Uri host, specific timeout.
System.Uri target = new System.Uri("http://www.example.com");
bool result = ((new System.Net.NetworkInformation.Ping())
.Send(target.Host, 3000).Status ==
System.Net.NetworkInformation.IPStatus.Success);
Play Method
♦ My.Computer.Audio.Play
Plays a sound contained in a file, byte array, or data stream.
VISUAL BASIC
' ----- Play sound file in background mode.
My.Computer.Audio.Play(soundFile, AudioPlayMode.Background)
C#
// ----- Play sound file in background mode.
System.Media.SoundPlayer audioSource =
new System.Media.SoundPlayer(soundFile);
audioSource.Play();
In addition to specifying a file containing sound content, the Play method accepts a byte array or stream. The SoundPlayer class will work with a data string, or a byte array wrapped in a stream.
C#
// ----- Sound contained in a stream.
System.Media.SoundPlayer audioSource =
new System.Media.SoundPlayer(existingStream);
// ----- Sound contained in a byte array.
System.IO.MemoryStream bytesAsStream =
new System.IO.MemoryStream(existingByteArray);
System.Media.SoundPlayer audioSource =
new System.Media.SoundPlayer(bytesAsStream);
// ----- Later...
bytesAsStream.Close();
The Play method accepts an argument that indicates how to play the sound, whether in the foreground, the background, or looping in the background. When using the SoundPlayer class in C#, call different methods to emulate the related AudioPlayModeenumeration value.
|
AudioPlayMode Value |
SoundPlayer Method |
|
Background |
Play |
|
BackgroundLoop |
PlayLooping |
|
WaitToComplete |
PlaySync |
PlaySystemSound Method
♦ My.Computer.Audio.PlaySystemSound
Plays a system-defined sound one time.
VISUAL BASIC
Dim whichSound As System.Media.SystemSound =
System.Media.SystemSounds.Beep
My.Computer.Audio.PlaySystemSound(whichSound)
C#
System.Media.SystemSound whichSound =
System.Media.SystemSounds.Beep;
whichSound.Play();
Ports Object
♦ My.Computer.Ports
See
OpenSerialPort Method, SerialPortNames Property
ProductName Property
♦ My.Application.Info.ProductName
Returns the product name as stored in the assembly.
VISUAL BASIC
Dim result As String = My.Application.Info.ProductName
C#
string result;
System.Reflection.Assembly currentAssembly =
System.Reflection.Assembly.GetEntryAssembly();
if (currentAssembly == null) currentAssembly =
System.Reflection.Assembly.GetCallingAssembly();
object[] attrSet = currentAssembly.GetCustomAttributes(
typeof(System.Reflection.AssemblyProductAttribute),
inherit:true);
if (attrSet.Length == 0)
result = "";
else
result = ((System.Reflection.AssemblyProductAttribute)
attrSet[0]).Product;
ProgramFiles Property
♦ My.Computer.FileSystem.SpecialDirectories.ProgramFiles
Returns the path to the native “program files” folder on the local system.
VISUAL BASIC
Dim result As String = My.Computer.FileSystem.
SpecialDirectories.ProgramFiles
C#
string result = System.Environment.GetFolderPath(
System.Environment.SpecialFolder.ProgramFiles);
Programs Property
♦ My.Computer.FileSystem.SpecialDirectories.Programs
Returns the path to the “program groups” folder for the current user.
VISUAL BASIC
Dim result As String = My.Computer.FileSystem.
SpecialDirectories.Programs
C#
string result = System.Environment.GetFolderPath(
System.Environment.SpecialFolder.Programs);
ReadAllBytes Method
♦ My.Computer.FileSystem.ReadAllBytes
Returns a byte array containing a file’s content.
VISUAL BASIC
Dim result As Byte() = My.Computer.FileSystem.ReadAllBytes(
"C:\temp\RawData.dat")
C#
byte[] result = System.IO.File.ReadAllBytes(
"C:\\temp\\RawData.dat");
ReadAllText Method
♦ My.Computer.FileSystem.ReadAllText
Returns a string containing a file’s content.
VISUAL BASIC
Dim optionalEncoding As System.Text.Encoding =
System.Text.UnicodeEncoding
Dim result As String = My.Computer.FileSystem.ReadAllText(
"C:\temp\WorkFile.txt", optionalEncoding)
C#
System.Text.Encoding optionalEncoding =
System.Text.UnicodeEncoding;
string result = System.IO.File.ReadAllText(
"C:\\temp\\WorkFile.txt", optionalEncoding);
The second argument to this method specifies an optional text encoding system. If absent, the text is read using the encoding specified by the file itself, if available.
Registry Object
♦ My.Computer.Registry
See
ClassesRoot Property, CurrentConfig Property, CurrentUser Property, DynData Property, GetValue Method, LocalMachine Property, PerformanceData Property, SetValue Method, Users Property
RenameDirectory Method
♦ My.Computer.FileSystem.RenameDirectory
Renames an existing directory, keeping it in the same original directory.
VISUAL BASIC
My.Computer.FileSystem.RenameDirectory(
"C:\temp\WorkArea", "BackupArea")
C#
System.IO.Directory.Move(
"C:\\temp\\WorkArea", "C:\\temp\\BackupArea");
The RenameDirectory method requires that the new name be just a directory name, with no path or drive information. The C# alternative allows either the source or destination path to be relative or absolute.
RenameFile Method
♦ My.Computer.FileSystem.RenameFile
Renames a file to a new name, keeping it in the same directory.
VISUAL BASIC
My.Computer.FileSystem.RenameFile(
"C:\temp\WorkFile.txt", "BackupWorkFile.old")
C#
System.IO.File.Move("C:\\temp\\WorkFile.txt",
"C:\\temp\\BackupWorkFile.old");
The RenameFile method requires that the new name be just a file name, with no path or drive information. The C# alternative allows either the source or destination path to be relative or absolute.
Request Object
♦ My.Request
Exposes request details for the current ASP.NET HTTP request.
VISUAL BASIC
Dim currentRequest As System.Web.HttpRequest = My.Request
C#
System.Web.HttpRequest currentRequest =
System.Web.HttpContext.Current.Request;
Resources Object
♦ My.Resources
Accesses resources defined through the Project Properties.
VISUAL BASIC
Dim template As String = My.Resources.DisplayTemplate
C#
string template = Properties.Resources.DisplayTemplate;
Response Object
♦ My.Response
Exposes response details for the current ASP.NET HTTP response.
VISUAL BASIC
Dim currentResponse As System.Web.HttpResponse =
My.Response
C#
System.Web.HttpResponse currentResponse =
System.Web.HttpContext.Current.Response;
Run Method
♦ My.Application.Run
Starts a Windows application using the Windows Forms Application Framework.
VISUAL BASIC
My.Application.Run(commandLineArgs)
The Run method is only available in VB programs that employ the Windows Forms Application Framework. The Application class in the System.Windows.Forms namespace also exposes a Run method. It provides similar functionality, but accepts a Form instance or an ApplicationContext instance instead of an array of command-line arguments. In C#, you can call the Environment.GetCommandLineArgs method to retrieve this information.
C#
// ----- Run the application focused on the
// main form instance.
Application.Run(new MainForm());
SaveMySettingsOnExit Property
♦ My.Application.SaveMySettingsOnExit
Indicates whether the settings should be saved when exiting the application.
VISUAL BASIC
Dim result As Boolean = My.Application.SaveMySettingsOnExit
C# does not include an equivalent for Visual Basic’s SaveMySettingsOnExit property. Instead, settings must be saved manually on exit. The following code saves any updated settings.
C#
Properties.Settings.Default.Save();
See Also
Settings Object
Screen Property
♦ My.Computer.Screen
Returns an object containing information and settings about the primary display.
VISUAL BASIC
Dim result As System.Windows.Forms.Screen =
My.Computer.Screen
C#
// ----- For Windows Forms code:
System.Windows.Forms.Screen result =
System.Windows.Forms.Screen.PrimaryScreen;
In XAML-centric code, the System.Windows.SystemParameters class exposes several static properties that provide screen-related information.
ScrollLock Property
♦ My.Computer.Keyboard.ScrollLock
Indicates whether the Scroll Lock key is currently activated.
VISUAL BASIC
Dim result As Boolean = My.Computer.Keyboard.ScrollLock
C#
// ----- For Windows Forms code:
bool result = System.Windows.Forms.Form.IsKeyLocked(
System.Windows.Forms.Keys.Scroll);
// ----- For XAML-centric code:
bool result = System.Windows.Input.Keyboard.IsKeyToggled(
System.Windows.Input.Key.Scroll);
SendKeys Method
♦ My.Computer.Keyboard.SendKeys
Sends keystrokes to the active window as if typed from the keyboard.
VISUAL BASIC
' ----- Send Control-C "copy" sequence to the
' active window.
Dim waitForProcessing As Boolean = True
My.Computer.Keyboard.SendKeys("^c", waitForProcessing)
C#
// ----- Send Control-C "copy" sequence to the
// active window.
System.Windows.Forms.SendKeys.SendWait("^c");
// ----- To return without waiting.
System.Windows.Forms.SendKeys.Send("^c");
XAML-based applications typically do not have access to the SendKeys class. Instead, such programs must call the SendInput Win32 API. Use of this API is beyond the scope of this chapter. Access the “SendInput Function” entry on Microsoft’s MSDN web site for information on calling this API.
The SendKeys command uses a set of specially formatted codes, such as {BACKSPACE}, to send non-standard characters and sequences to the target window. See the Visual Studio documentation for the full set of codes.
SerialPortNames Property
♦ My.Computer.Ports.SerialPortNames
Returns a collection of serial port names found on the local computer.
VISUAL BASIC
' ----- This code returns a read-only collection of
' the serial port names.
Dim result As System.Collections.Generic.
ReadOnlyCollection(Of String) =
My.Computer.Ports.SerialPortNames
C#
// ----- This code returns an ordinary string array of
// the serial port names.
string[] result =
System.IO.Ports.SerialPort.GetPortNames();
SetAudio Method
♦ My.Computer.Clipboard.SetAudio
Writes audio data to the system clipboard. The audio content supplied can be in the form of a byte array or a stream (System.IO.Stream).
VISUAL BASIC
' Option 1: Dim audioContent() As Byte
' Option 2: Dim audioContent As System.IO.Stream
My.Computer.Clipboard.SetAudio(audioContent)
C#
// Option 1: byte[] audioContent;
// Option 2: System.IO.Stream audioContent;
// ----- For Windows Forms code:
System.Windows.Forms.Clipboard.SetAudio(audioContent);
// ----- For XAML-centric code:
System.Windows.Clipboard.SetAudio(audioContent);
SetData Method
♦ My.Computer.Clipboard.SetData
Writes data in a custom named format to the system clipboard.
VISUAL BASIC
Dim formatName As String = "MyCustomFormat"
Dim customData As Object ' Assign any data you choose
My.Computer.Clipboard.SetData(formatName, customData)
C#
string formatName = "MyCustomFormat";
object customData; // Assign any data you choose
// ----- For Windows Forms code:
System.Windows.Forms.Clipboard.SetData(
formatName, customData);
// ----- For XAML-centric code:
System.Windows.Clipboard.SetData(
formatName, customData);
SetDataObject Method
♦ My.Computer.Clipboard.SetDataObject
Writes data to the system clipboard in multiple formats at once.
VISUAL BASIC
Dim toClipboard As New System.Windows.Forms.DataObject
toClipboard.SetText("Some basic text.")
toClipboard.SetData("Backwards", ".txet cisab emoS")
My.Computer.Clipboard.SetDataObject(toClipboard)
C#
// ----- For Windows Forms code:
System.Windows.Forms.DataObject toClipboard =
new System.Windows.Forms.DataObject();
toClipboard.SetText("Some basic text.");
toClipboard.SetData("Backwards", ".txet cisab emoS");
System.Windows.Forms.Clipboard.SetDataObject(toClipboard);
// ----- For XAML-centric code:
System.Windows.DataObject toClipboard =
new System.Windows.DataObject();
toClipboard.SetText("Some basic text.");
toClipboard.SetData("Backwards", ".txet cisab emoS");
System.Windows.Clipboard.SetDataObject(toClipboard);
SetFileDropList Method
♦ My.Computer.Clipboard.SetFileDropList
Writes a collection of file-path strings to the system clipboard.
VISUAL BASIC
Dim files As New _
System.Collections.Specialized.StringCollection
files.Add("C:\temp\FileToShare.txt")
My.Computer.Clipboard.SetFileDropList(files)
C#
System.Collections.Specialized.StringCollection files =
new System.Collections.Specialized.StringCollection();
files.Add("C:\\temp\\FileToShare.txt");
// ----- For Windows Forms code:
System.Windows.Forms.Clipboard.SetFileDropList(files);
// ----- For XAML-centric code:
System.Windows.Clipboard.SetFileDropList(files);
SetImage Method
♦ My.Computer.Clipboard.SetImage
Writes an image to the system clipboard.
VISUAL BASIC
Dim someImage As System.Drawing.Image
' ----- After loading the image.
My.Computer.Clipboard.SetImage(someImage)
C#
// ----- For Windows Forms code:
System.Drawing.Image someImage;
System.Windows.Forms.Clipboard.SetImage(someImage);
// ----- For XAML-centric code:
System.Windows.Media.Imaging.BitmapSource someImage;
System.Windows.Clipboard.SetImage(someImage);
SetText Method
♦ My.Computer.Clipboard.SetText
Writes a text string to the system clipboard.
VISUAL BASIC
My.Computer.Clipboard.SetText("Hello, world!")
C#
// ----- For Windows Forms code:
System.Windows.Forms.Clipboard.SetText("Hello, world!");
// ----- For XAML-centric code:
System.Windows.Clipboard.SetText("Hello, world!");
The SetText method accepts a second optional argument that indicates the type of text to store, such as HTML or Unicode. In the My and Windows Forms versions of the code, this argument is of type System.Windows.Forms.TextDataFormat; for XAML code, use the System.Windows.TextDataFormat enumeration instead. By default, the text is stored in Unicode format.
Settings Object
♦ My.Settings
Accesses user and application settings defined through the Project Properties.
VISUAL BASIC
' ----- Accessing a setting.
Dim result As Point = My.Settings.DisplayLocation
' ----- Modifying a setting (user-scope only).
My.Settings.DisplayLocation = targetForm.Location
' ----- Saving all settings.
My.Settings.Save()
C#
// ----- Accessing a setting.
Point result = Properties.Settings.Default.DisplayLocation;
// ----- Modifying a setting (user-scope only).
Properties.Settings.Default.DisplayLocation =
targetForm.Location;
// ----- Saving all settings.
Properties.Settings.Default.Save();
SetValue Method
♦ My.Computer.Registry.SetValue
Saves data into a specified Windows registry value.
VISUAL BASIC
My.Computer.Registry.SetValue(
"HKEY_CURRENT_USER\Software\Example\MyApp",
"ErrorCount", 0&, RegistryValueKind.QWord))
C#
Microsoft.Win32.Registry.SetValue(
"HKEY_CURRENT_USER\\Software\\Example\\MyApp",
"ErrorCount", 0L, RegistryValueKind.QWord);
ShiftKeyDown Property
♦ My.Computer.Keyboard.ShiftKeyDown
Indicates whether a Shift key is currently pressed.
VISUAL BASIC
Dim result As Boolean = My.Computer.Keyboard.ShiftKeyDown
C#
// ----- For Windows Forms code:
bool result = ((System.Windows.Forms.Control.ModifierKeys &
System.Windows.Forms.Keys.Shift) != 0);
// ----- For XAML-centric code:
bool result = ((System.Windows.Input.Keyboard.Modifiers &
System.Windows.Input.ModifierKeys.Shift) != 0);
Shutdown Event
♦ My.Application.Shutdown
Occurs when the application shuts down.
VISUAL BASIC
Public Sub Me_Shutdown(ByVal sender As Object,
ByVal e As EventArgs) Handles Me.Shutdown
' ----- Relevant shutdown code here.
End Sub
The Shutdown event is only available in VB programs that employ the Windows Forms Application Framework. However, you can perform shutdown-related processing in any application by adding a handler to the ProcessExit event for the current application domain.
C#
static void ShutdownLogic(object sender, EventArgs e)
{
// ----- Relevant shutdown code here.
}
// ----- In your Main routine, before running the core
// program logic.
AppDomain.CurrentDomain.ProcessExit += ShutdownLogic;
The application context object for an application exposes a similar event that you can use instead of ProcessExit to monitor the application’s main thread.
C#
// ----- In your Main routine.
ApplicationContext appContext = new ApplicationContext();
appContext.ThreadExit += ShutdownLogic;
appContext.MainForm = new Form1();
Application.Run(appContext);
SpecialDirectories Object
♦ My.Computer.FileSystem.SpecialDirectories
See
AllUsersApplicationData Property, CurrentUserApplicationData Property, Desktop Property, MyDocuments Property, MyMusic Property, MyPictures Property, Programs Property, Temp Property
SplashScreen Property
♦ My.Application.SplashScreen
Identifies the form used as the splash screen in a Windows Forms application.
VISUAL BASIC
My.Application.SplashScreen = New SplashForm
Visual Basic includes features that let you display a splash screen with some basic logic. In C#, any splash screen must be displayed manually through custom code. The following method can be called from the Main method to display a splash screen.
C#
// ----- Call this routine from Main.
private static void ShowSplashScreen()
{
// ----- Show the splash screen on its own thread.
System.Threading.Thread splashThread =
new System.Threading.Thread(DisplaySplash);
splashThread.Start();
}
private static void DisplaySplash()
{
// ----- Assume a form with an exposed timer that
// will close the form after some time.
Application.Run(new SplashForm());
}
StackTrace Property
♦ My.Application.Info.StackTrace
Returns a string version of the current stack trace.
VISUAL BASIC
Dim result As String = My.Application.Info.StackTrace
C#
string result = System.Environment.StackTrace;
Startup Event
♦ My.Application.Startup
Triggered when starting a Windows Forms application that uses VB’s Windows Forms Application Framework.
VISUAL BASIC
Public Sub Me_Startup(ByVal sender As Object,
ByVal e As StartupEventArgs) Handles Me.Startup
' ----- Custom startup code here. To abort...
e.Cancel = True
End Sub
C# does not include an equivalent to VB’s Windows Forms Application Framework. However, because all C# programs begin with a Main method, you can place relevant custom code directly in that method.
C#
public static void Main()
{
// ----- Custom code here. To abort...
Application.Exit();
}
StartupNextInstance Event
♦ My.Application.StartupNextInstance
Called when a subsequent instance of a single-instance Windows Forms application starts up. The event occurs in the primary instance.
VISUAL BASIC
Public Sub Me_StartupNextInstance(ByVal sender As Object,
ByVal e As StartupNextInstanceEventArgs) _
Handles Me.StartupNextInstance
' ----- Instance-handling code here.
End Sub
The StartupNextInstance event is only available in VB programs that employ the Windows Forms Application Framework. In C#, you must monitor the startup of subsequent instances manually. The following Main method provides an example of how you can watch for subsequent instances using a shared mutex object.
C#
// ----- Assumes: using System.Threading;
public static void Main()
{
System.Version versionInfo;
string mutexName;
Mutex appMutex = null;
bool firstInstance = false;
// ----- Provide a reasonably unique mutex name.
// GUIDs will also work.
versionInfo = System.Reflection.Assembly.
GetExecutingAssembly().GetName().Version;
mutexName = string.Format(
"VendorName/AppName({0}.{1})",
versionInfo.Major, versionInfo.Minor);
try
{
// ----- See if another instance exists.
appMutex = Mutex.OpenExisting(mutexName);
}
catch
{
// ----- Not found or other failure.
// Try to create one.
try
{
appMutex = new Mutex(true, mutexName,
out firstInstance);
}
catch
{
firstInstance = false;
}
}
if (firstInstance)
{
// ----- Continue with application logic.
}
else
{
// ----- This is a subsequent instance.
}
// ----- When finished with the app, clean up.
if (appMutex != null)
appMutex.Close();
}
Visual Basic’s StartupNextInstance shuts down the subsequent instance and passes any of its command-line arguments to the first instance through the event’s e argument. It does this through interprocess communications, a demonstration of which is beyond the scope of this entry.
Stop Method
♦ My.Computer.Audio.Stop
Stops a sound that is currently playing.
VISUAL BASIC
' ----- Play sound file in background mode.
My.Computer.Audio.Play(soundFile, AudioPlayMode.Background)
' ----- Later, stop the sound.
My.Computer.Audio.Stop()
C#
// ----- Play sound file in background mode.
System.Media.SoundPlayer audioSource =
new System.Media.SoundPlayer(soundFile);
audioSource.Play();
// ----- Later, stop the sound.
audioSource.Stop();
Temp Property
♦ My.Computer.FileSystem.SpecialDirectories.Temp
Returns the path to the temporary-file folder for the current user.
VISUAL BASIC
Dim result As String = My.Computer.FileSystem.
SpecialDirectories.Temp
C#
string result = System.IO.Path.GetTempPath();
TextFieldParser Object
See
OpenTextFieldParser Method
TickCount Property
♦ My.Computer.Clock.TickCount
Returns the number of milliseconds elapsed since system startup, or since the last time the counter reset, about once every 25 days.
VISUAL BASIC
Dim result As Integer = My.Computer.Clock.TickCount
C#
int result = System.Environment.TickCount;
Title Property
♦ My.Application.Info.Title
Returns the application title as stored in the assembly.
VISUAL BASIC
Dim result As String = My.Application.Info.Title
C#
string result;
System.Reflection.Assembly currentAssembly =
System.Reflection.Assembly.GetEntryAssembly();
if (currentAssembly == null) currentAssembly =
System.Reflection.Assembly.GetCallingAssembly();
object[] attrSet = currentAssembly.GetCustomAttributes(
typeof(System.Reflection.AssemblyTitleAttribute),
inherit:true);
if (attrSet.Length == 0)
result = "";
else
result = ((System.Reflection.AssemblyTitleAttribute)
attrSet[0]).Title;
TotalPhysicalMemory Property
♦ My.Computer.Info.TotalPhysicalMemory
Returns the total number of installed bytes of physical memory on the local computer.
VISUAL BASIC
Dim result As ULong = My.Computer.Info.TotalPhysicalMemory
C#
// ----- GetMemoryInfo code discussed below.
ulong result = MemoryQuery.GetMemoryInfo().TotalPhysical;
Visual Basic retrieves memory information through the GlobalMemoryStatusEx Windows API call. See the “AvailablePhysicalMemory Property” entry in this chapter for a sample GetMemoryInfo method that wraps the API call in C# code.
TotalVirtualMemory Property
♦ My.Computer.Info.TotalVirtualMemory
Returns the total number of configured bytes of virtual memory on the local computer.
VISUAL BASIC
Dim result As ULong = My.Computer.Info.TotalVirtualMemory
C#
// ----- GetMemoryInfo code discussed below.
ulong result = MemoryQuery.GetMemoryInfo().TotalVirtual;
Visual Basic retrieves memory information through the GlobalMemoryStatusEx Windows API call. See the “AvailablePhysicalMemory Property” entry in this chapter for a sample GetMemoryInfo method that wraps the API call in C# code.
TraceSource Property
♦ My.Application.Log.TraceSource (for Desktop applications)
♦ My.Log.TraceSource (for ASP.NET applications)
Unlike with Visual Basic, C# does not configure a built-in logging environment by default. Instead, you can add a Logging Application Block from the Microsoft Enterprise Library to your application. The code needed to set up and use trace logging in your application is beyond the scope of this book.
You can find full information on the Logging Application Block, including sample code, on the MSDN web site, msdn.microsoft.com. On that site, search for “Enterprise Library 6.” The first result should be a link to the Developer’s Guide for the Microsoft Enterprise Library. Chapter 5, “As Easy As Falling Off a Log,” provides an overview of the logging components.
Visual Basic’s logging tools include WriteEntry and WriteException methods. In the sample code for the Logging Application Block, the LogWriter.Write method provides a good substitute for VB’s own WriteEntry method. However, the Enterprise Library does not include a write method designed for Exception instances. Instead, you must format the exception message yourself, and then pass it to the LogWriter.Write method.
Trademark Property
♦ My.Application.Info.Trademark
Returns the legal trademark as stored in the assembly.
VISUAL BASIC
Dim result As String = My.Application.Info.Trademark
C#
string result;
System.Reflection.Assembly currentAssembly =
System.Reflection.Assembly.GetEntryAssembly();
if (currentAssembly == null) currentAssembly =
System.Reflection.Assembly.GetCallingAssembly();
object[] attrSet = currentAssembly.GetCustomAttributes(
typeof(System.Reflection.AssemblyTrademarkAttribute),
inherit:true);
if (attrSet.Length == 0)
result = "";
else
result = ((System.Reflection.
AssemblyTrademarkAttribute)
attrSet[0]).Trademark;
UICulture Property
♦ My.Application.UICulture
Returns an object that describes the user interface culture.
VISUAL BASIC
Dim result As System.Globalization.CultureInfo =
My.Application.UICulture
C#
System.Globalization.CultureInfo result =
System.Threading.Thread.CurrentThread.CurrentUICulture;
UnhandledException Event
♦ My.Application.UnhandledException
Catches unhandled exceptions within a Windows Forms application that uses VB’s Windows Forms Application Framework.
VISUAL BASIC
Public Sub Me_UnhandledException(ByVal sender As Object,
ByVal e As UnhandledExceptionEventArgs) _
Handles Me.UnhandledException
' ----- Relevant error-handling code here.
End Sub
The UnhandledException event is only available in VB programs that employ the Windows Forms Application Framework. However, you can manage unhandled exceptions in any application by adding a handler to the UnhandledException event for the current application domain.
C#
static void SurpriseProblem(object sender,
UnhandledExceptionEventArgs e)
{
// ----- Relevant error-handling code here.
}
// ----- In your Main routine, before running the core
// program logic.
AppDomain.CurrentDomain.UnhandledException +=
SurpriseProblem;
You can also add a thread-specific handler that monitors unhandled exceptions in your main (UI) thread.
C#
static void ThreadProblem(object sender,
System.Threading.ThreadExceptionEventArgs e)
{
// ----- Relevant error-handling code here.
}
// ----- In your Main routine, before running the core
// program logic.
Application.ThreadException += ThreadProblem;
UploadFile Method
♦ My.Computer.Network.UploadFile
Uploads a file from a local computer to a network address.
VISUAL BASIC
My.Computer.Network.UploadFile(sourceFile,
destinationAddress, userName, password)
C#
System.Net.WebClient client = new System.Net.WebClient();
System.Uri destinationUri =
new System.Uri(destinationAddress);
// ----- Default credentials.
client.UseDefaultCredentials = true;
// ----- Or, supply specific credentials.
client.UseDefaultCredentials = false;
client.Credentials = new System.Net.NetworkCredential(
userName, password);
// ----- Synchronous copy.
client.UploadFile(destinationUri, sourceFile);
// ----- Or, asynchronous copy, providing your own
// custom complete/cancel event handler.
client.UploadFileCompleted += new
UploadFileCompletedEventHandler(CompletedCallback);
client.UploadFileAsync(destinationUri, sourceFile);
The WebClient class’ upload methods provide no visual cues as to the state of the transfer. You must provide your own progress dialog if desired.
To override the default timeout value, derive a new class from the WebClient class, and manually configure the WebRequest’s TimeOut property. Then use this class instead of the standard WebClient class to perform the upload. For a sample of this override in C#, see the “DownloadFile Method” entry in this chapter.
See Also
DownloadFile Method
User Object
♦ My.User
See
CurrentPrincipal Property, InitializeWithWindowsUser Method, IsAuthenticated Property, IsInRole Method, Name Property (My.User)
Users Property
♦ My.Computer.Registry.Users
Returns a reference to the HKEY_USERS Windows registry location.
VISUAL BASIC
Dim result As Microsoft.Win32.RegistryKey =
My.Computer.Registry.Users
C#
Microsoft.Win32.RegistryKey result =
Microsoft.Win32.Registry.Users;
Version Property
♦ My.Application.Info.Version
Returns the version numbers of the application as stored in the assembly.
VISUAL BASIC
Dim result As System.Version = My.Application.Info.Version
C#
System.Reflection.Assembly currentAssembly =
System.Reflection.Assembly.GetEntryAssembly();
if (currentAssembly == null) currentAssembly =
System.Reflection.Assembly.GetCallingAssembly();
System.Version result = currentAssembly.GetName().Version;
WebServices Object
♦ My.WebServices
Accesses web services and their members from a non-ASP.NET application.
VISUAL BASIC
' ----- Assumes a MappingService web service with a
' GetNearestCity member is part of the project.
Dim result As String =
My.WebServices.MappingService.GetNearestCity(
targetLatitude, targetLongitude)
C#
// ----- Assumes a MappingService web service with a
// GetNearestCity member is part of the project.
MappingNamespace.MappingService theService =
new MappingNamespace.MappingService();
string result = theService.GetNearestCity(
targetLatitude, targetLongitude);
WheelExists Property
♦ My.Computer.Mouse.WheelExists
Returns a value that indicates whether the installed mouse includes a mouse wheel.
VISUAL BASIC
Dim result As Boolean = My.Computer.Mouse.WheelExists
C#
// ----- For Windows Forms code:
bool result = System.Windows.Forms.SystemInformation.
MouseWheelPresent;
// ----- For XAML-centric code:
bool result = System.Windows.SystemParameters.
IsMouseWheelPresent;
WheelScrollLines Property
♦ My.Computer.Mouse.WheelScrollLines
Returns the number of lines to scroll during mouse wheel operations.
VISUAL BASIC
Dim result As Integer = My.Computer.Mouse.WheelScrollLines
C#
// ----- For Windows Forms code:
int result = System.Windows.Forms.SystemInformation.
MouseWheelScrollLines;
// ----- For XAML-centric code:
int result =
System.Windows.SystemParameters.WheelScrollLines;
WorkingSet Property
♦ My.Application.Info.WorkingSet
Returns the size in bytes of physical memory mapped to the current process context.
VISUAL BASIC
Dim result As Long = My.Application.Info.WorkingSet
C#
long result = System.Environment.WorkingSet;
WriteAllBytes Method
♦ My.Computer.FileSystem.WriteAllBytes
Writes the content of a byte array to a specified file.
VISUAL BASIC
Dim whichFile As String = "C:\temp\SomeData.dat"
Dim theData() As Byte = GetMyByteData()
Dim append As Boolean = False
My.Computer.FileSystem.WriteAllBytes(
whichFile, theData, append)
C#
string whichFile = "C:\\temp\\SomeData.dat";
byte[] theData = GetMyByteData();
bool append = false;
System.IO.FileStream outFile;
System.IO.FileMode outMethod;
if (append)
outMethod = System.IO.FileMode.Append;
else
outMethod = System.IO.FileMode.Create;
outFile = new System.IO.FileStream(whichFile, outMethod,
System.IO.FileAccess.Write, System.IO.FileShare.Read);
outFile.Write(theData, 0, theData.Length);
outFile.Close();
WriteAllText Method
♦ My.Computer.FileSystem.WriteAllText
Writes text content to a specified file.
VISUAL BASIC
Dim filePath As String = "C:\temp\Output.txt"
Dim content As String = "Hello, world!" + vbCrLf
Dim appendFlag As Boolean = False
Dim optionalEncoding As System.Text.Encoding =
New System.Text.UTF8Encoding
My.Computer.FileSystem.WriteAllText(
filePath, content, appendFlag, optionalEncoding)
C#
string filePath = "C:\\temp\\Output.txt";
string content = "Hello, world!\r\n";
System.Text.Encoding optionalEncoding =
new System.Text.UTF8Encoding();
// ----- To create or overwrite a file:
System.IO.File.WriteAllText(
filePath, content, optionalEncoding);
// ----- To append to an existing file:
System.IO.File.AppendAllText(
filePath, content, optionalEncoding);
WriteEntry Method
♦ My.Application.Log.WriteEntry (for Desktop applications)
♦ My.Log.WriteEntry (for ASP.NET applications)
Writes a message to the logging system.
See
TraceSource Property
WriteException Method
♦ My.Application.Log.WriteException (for Desktop applications)
♦ My.Log.WriteException (for ASP.NET applications)
Writes an exception to the logging system.
See
TraceSource Property