static extern int system(string command);

Public Declare Function system Lib "msvcrt.dll" (ByVal sCommand As String) As Long

   Public Declare Function system Lib "msvcrt.dll" (ByVal sCommand As String) As Long

        HTMLHelpCommand command,

    public enum HTMLHelpCommand : uint

     ByVal uCommand As Integer, ByVal dwData As IntPtr) As Integer

Public Enum HTMLHelpCommand

HTMLHelp(Nothing, filePath, HTMLHelpCommand.HH_HELP_CONTEXT, contextID)

HTMLHelp(Nothing, filePath, HTMLHelpCommand.HH_DISPLAY_TOC, 0)

HtmlHelp(IntPtr.Zero, filePath, HTMLHelpCommand.HH_HELP_CONTEXT, contextID)

HtmlHelp(IntPtr.Zero, filePath, HTMLHelpCommand.HH_DISPLAY_TOC, 0)

        HTMLHelpCommand uCommand,

    HtmlHelp(IntPtr.Zero, null, HTMLHelpCommand.HH_DISPLAY_TEXT_POPUP, param);

public static extern bool FtpCommandA

[MarshalAs(UnmanagedType.VBByRefStr)] ref string lpszCommand,

IntPtr phFtpCommand);

Declare Function FtpCommandA Lib "wininet.dll" _

ByVal lpszCommand As String, _

ByVal phFtpCommand As IntPtr) As <MarshalAs(UnmanagedType.Bool)> Boolean

lpszCommand (in) A pointer to a string that contains the command to send to the FTP server.

phFtpCommand (out) A pointer to a handle that is created if a valid data socket is opened. The fExpectResponse parameter must be set to TRUE for phFtpCommand to be filled.

Dim ret As Boolean = FTPCommandA(ConnectionHandle, False, 0, sCommand, IntPtr.Zero, IntPtr.Zero)

   COMMAND = 1,

   DDECOMMAND,

   qa.GetString(ASSOCF.NOTRUNCATE, ASSOCSTR.COMMAND,

   qa.GetString(ASSOCF.NOTRUNCATE, ASSOCSTR.COMMAND,

     Console.WriteLine("No command line is associated to .doc print verb.");

    Command = 1,

    DDECommand,

/// Finds the command line arguments within a given path.

''' Finds the command line arguments within a given path.

static extern UInt32 MsiApplyPatch(string patchPackage, string installPackage, INSTALLTYPE installType, string commandLine);

commandLine

   Specifies command line property settings

static extern UInt32 MsiInstallProduct(string packagePath, string commandLine);

Declare Function MsiInstallProduct Lib "msi.dll" (packagePath As String, commandLine As String) As UInt32

szCommandLine

A null-terminated string that specifies the command line property settings. This should be a list of the format Property=Setting Property=Setting. For more information, see About Properties.

To perform an administrative installation, include ACTION=ADMIN in szCommandLine. For more information, see the ACTION property.

You can completely remove a product by setting REMOVE=ALL in szCommandLine.

        // The sql command. Note the "?" placeholder for the value.

        // Open a view to use to apply the change. Here's where you specify your sql command.

With all the different information you can get with just one command; this one sure is difficult. Very, very little documentation on this because Microsoft probably doesn't want easy access to these. My company has allowed me to contribute my findings as long as I mention it. We are Digital Boundary Group, based in London, Ontario, Canada, and we do penetration testing. Please visit us at http://digitalboundary.net I will be allowed to continue my contributions as long as my company does not lose credit for its contributions.

This is a simple console program which lets you send messages (quite similar to the NET SEND command...).

    /// The command to run.

    public string Command;

        public int CurrentCommands;

private extern static int dmAPIExec(string command);    

public  bool Exec(string command, params object[] args)

    string cmd = String.Format(null,command, args);

public string Get(string command, params object[] args)

    string cmd  = String.Format(null,command, args);

static extern bool FtpCommand(IntPtr hConnect, bool fExpectResponse, [MarshalAs(UnmanagedType.U4)] int dwFlags, string lpszCommand, IntPtr dwContext, ref IntPtr phFtpCommand);

Private Shared Function FtpCommand(ByVal hConnect As IntPtr, ByVal fExpectResponse As Boolean, <MarshalAs(UnmanagedType.U4)> ByVal dwFlags As Integer, ByVal lpszCommand As String, ByVal dwContext As IntPtr, ByRef phFtpCommand As IntPtr) As Boolean

tcc (http://bellard.org/tcc/) command line to compile:

gcc (under cygwin) command line to compile:

        failureActions.lpCommand = "";

        failureActions.lpCommand = "";

    string lpCommandLine,

    ByVal strCommandLine As String, _

                           <[In](), Out(), [Optional]()> ByVal lpCommandLine As StringBuilder, _

Use StringBuilder for lpCommandLine parameter for unicode version of this function.

     if (!CreateProcessAsUser(hToken, String.Empty, commandLine,

     String             commandLine,

    Public Function CreateProcessWithLogonW(ByVal userName As String, ByVal domain As String, ByVal password As String, ByVal logonFlags As UInt32, ByVal applicationName As String, ByVal commandLine As String, ByVal creationFlags As UInt32, ByVal environment As UInt32, ByVal currentDirectory As String, ByRef startupInfo As StartupInfo, ByRef processInformation As ProcessInformation) As Boolean

    Public Function CreateProcessWithLogonW(ByVal userName As String, ByVal domain As String, ByVal password As String, ByVal logonFlags As UInt32, ByVal applicationName As String, ByVal commandLine As String, ByVal creationFlags As UInt32, ByVal environment As UInt32, ByVal currentDirectory As String, ByRef startupInfo As StartupInfo, ByRef processInformation As ProcessInformation) As Boolean

    Dim command As String = "c:\windows\Notepad.exe"

        command, command, Convert.ToUInt32(0), Convert.ToUInt32(0), _

            String commandLine,

            String command = @"c:\windows\notepad.exe";

                    command,

                    command,

        Console.WriteLine( "Command line: {0}", failureActions.lpCommand );

        public string lpCommand;

        Console.WriteLine( "Command line: {0}", failureActions.lpCommand );

        public string lpCommand;

    /// Run a command.

    SC_ACTION_RUN_COMMAND = 3

        public string lpCommand;

        // execute this command, to convert pdf to tiff

    public struct CMINVOKECOMMANDINFOEX {

        public int            cbSize;        // Marshal.SizeOf(CMINVOKECOMMANDINFO)

        public int            dwHotKey;        // Optional hot key to assign to any application activated by the command. If the fMask member does not specify CMIC_MASK_HOTKEY, this member is ignored.

        public IntPtr        hIcon;            // Icon to use for any application activated by the command. If the fMask member does not specify CMIC_MASK_ICON, this member is ignored.

        public string        lpVerbW;                // Unicode verb, for those commands that can use it.

        public string        lpParametersW;        // Unicode parameters, for those commands that can use it.

        public string        lpDirectoryW;        // Unicode directory, for those commands that can use it.

        public POINT        ptInvoke;                // Point where the command is invoked. This member is not valid prior to Microsoft Internet Explorer 4.0.

Structure CMINVOKECOMMANDINFOEX

public static extern bool CreateProcessWithTokenW(IntPtr hToken, LogonFlags dwLogonFlags, string lpApplicationName, string lpCommandLine, CreationFlags dwCreationFlags, IntPtr lpEnvironment, string lpCurrentDirectory, [In] ref STARTUPINFO lpStartupInfo, out PROCESS_INFORMATION lpProcessInformation);

    Public Shared Function CreateProcessWithTokenW(hToken As IntPtr, dwLogonFlags As Integer, lpApplicationName As String, lpCommandLine As String, dwCreationFlags As Integer, lpEnvironment As IntPtr, lpCurrentDirectory As IntPtr, ByRef lpStartupInfo As STARTUPINFO, ByRef lpProcessInformation As PROCESS_INFORMATION) As Boolean

  *  Structure returned to the NCB command NCBENUM.

        public uint dwCommandId;

        byte ncb_command;

   Dim ncb_command As Byte

   UCHAR   ncb_command;        /* command code           */

                   /* state when an ASYNCH command   */

        public ushort Command;

    /// Wrapper for the ScsiPassThrough command

        /// Constructor for the command to send to the robot

            public string lpCommand;

   Public lpCommand As String

        public int CurrentCommands;

    public bool CommandQueueing;

        public int idCommand;

        Public idCommand As Int32

        public int idCommand;

     public ShowWindowCommands ShowCmd;

     Public showCmd As ShowWindowCommand

POINT, RECT, ShowWindowCommands

static extern Int32 mciSendString(string command, StringBuilder buffer, int bufferSize, IntPtr hwndCallback);

Private Shared Function mciSendString(ByVal command As String, ByVal buffer As StringBuilder, ByVal bufferSize As Integer, ByVal hwndCallback As IntPtr) As Integer

Declare Ansi Function mciSendString Lib "winmm.dll" Alias "mciSendStringA" (ByVal command As String, ByRef buffer As StringBuilder, ByVal bufferSize As Integer, ByVal hWndCallback As IntPtr) As Integer

string sCommand = "open \"" + strFilePath + "\" type mpegvideo alias MediaFile";

mciSendString(sCommand, null, 0, 0);

sCommand = "play MediaFile notify";

mciSendString(sCommand, null, 0, _frmObject.Handle.ToInt64());

static extern Int32 mciSendString(string command, string buffer, int bufferSize, IntPtr hwndCallback);

private void EjectCdCommand()

private void CloseCdCommand()

     Dim sCommand As String = "open """ + strFilePath + """ type waveaudio alias MediaFile"

     mciSendString(sCommand, Nothing, 0, IntPtr.Zero)

     sCommand = "play MediaFile notify"

     mciSendString(sCommand, Nothing, 0, Me.Handle.ToInt64())

http://blogs.msdn.com/noahc/archive/2009/06/04/eject-or-undock-a-laptop-pc-from-command-line-or-c.aspx

TextOut, unlike the Text property, have to be called every time Windows asks for a control to repaint. By using the Graphics.CopyFromScreen method one can copy the output of a Textout command and use that for repainting.

Unlike graphics.drawstring, Textout can work with fonts other than True Type, Open Type, and PostScript fonts. If you have a font that's supported by Windows but not .net you can most likely use this command to draw it.

        byte[] sendBytes = new byte[] { 0xFF, 0xCA, 0x00, 0x00, 0x00 }; //get UID command for iClass cards

If you need to check for an existing console (ie, if the program was launched from the command window) please see AttachConsole,

When running an application that is GUI from a console window, you may want to echo something to that console window (such as command line options when the user specifies /? on the command line), but also don't want a console window popping up when you don't need it (such is the behavior of a windows C# 'Console Application'). In this case these work great, and are fully compatible thereafter with the .NET Console.xxx static functions.

When running an application that is GUI from a console window, you may want to echo something to that console window (such as command line options when the user specifies /? on the command line), but also don't want a console window popping up when you don't need it (such is the behavior of a windows C# 'Console Application'). In this case these work great, and are fully compatible thereafter with the .NET Console.xxx static functions.

        public uint dwCommandId;

   string lpCommandLine,

    lpCommandLine As String, _

     string CommandLine = @" c:\boot.ini";

     retValue = CreateProcess(Application,CommandLine,

     Dim CommandLine As String = " c:\boot.ini"

     retValue = CreateProcess(Application, CommandLine, pSec, tSec, False, NORMAL_PRIORITY_CLASS, IntPtr.Zero, vbNull, sInfo, pInfo)

     DiskSmartSendDriveCommand = (EFileDevice.Disk << 16) | (0x0021 << 2) | EMethod.Buffered | (FileAccess.ReadWrite << 14),

   Private Const DFP_SEND_DRIVE_COMMAND As Integer = &H7C084

       Dim bFeaturesReg As Byte     ' // Used for specifying SMART "commands".

       Dim bCommandReg As Byte      ' // Actual IDE command.

       Dim bDriveNumber As Byte    ' Physical drive number to send command to (0,1,2,3).

       'Issue a Command GET VERSION and test results

       'Issue a full IDE Command

           .bCommandReg = CByte(IDE_ID_FUNCTION)

private static extern System.IntPtr GetCommandLine();

The original GetCommandLine function returns a pointer to a buffer allocated and owned by the operating system. When marshaling strings as return types, the interop marshaler assumes it must free the memory that the original LPTSTR type pointed to by the function. To prevent the marshaler from automatically reclaiming this memory, the managed GetCommandLine prototype returns an IntPtr type instead of a string. The Marshal.PtrToStringAuto method copies the unmanaged LPSTR type to a managed string object, widening the character format, if required.

Use this API function when you need access to raw command line string and not already parsed arguments in Main(string[] args)

System.IntPtr ptr = GetCommandLine();

string commandLine = Marshal.PtrToStringAuto(ptr);

Environment.CommandLine

Private Function ShowWindow(ByVal hwnd As IntPtr, ByVal nCmdShow As ShowWindowCommands) As Boolean

Enum ShowWindowCommands As Integer

    ShowWindow(hwnd, ShowWindowCommands.ShowMinimized)

    public Commands ncb_command;      /* command code           */

                    /* state when an ASYNCH command   */

   Dim ncb_command As Byte

   myNcb.ncb_command = NCBENUM

   ' execute the NetBIOS command

   myNcb.ncb_command = NCBRESET

   ' execute the NetBIOS command

   myNcb.ncb_command = NCBASTAT

   ' execute the NetBIOS command

  ' issue all commands to the NetBIOS protocol

    Public ncbCommand As Byte

static extern int RegisterApplicationRestart([MarshalAs(UnmanagedType.LPWStr)] string commandLineArgs, int Flags);

Declare Function RegisterApplicationRestart Lib "kernel32.dll" (commandLineArgs As String, Flags As Integer) As Integer

commandLineArgs

A pointer to a Unicode string that specifies the command-line arguments for the application when it is restarted. The maximum size of the command line that you can specify is RESTART_MAX_CMD_LINE characters. Do not include the name of the executable in the command line; this function adds it for you.

If this parameter is NULL or an empty string, the previously registered command line is removed. If the argument contains spaces, use quotes around the argument.

Your initial registration for restart must occur before the application encounters an unhandled exception or becomes unresponsive. You could then call this function from inside your recovery callback to update the command line.

private static extern uint RegisterApplicationRestart(string pwsCommandLine, RestartFlags dwFlags);

    uint MF_BYCOMMAND = 0x00000000;

    string lpCommandLine,

    uint MF_BYCOMMAND = 0x00000000;

Use MF_BYCOMMAND to specify the item ID on [itemId] parameter or use MF_BYPOSITION to specify the zero-based index of the item, if neither MF_BYCOMMAND nor MF_BYPOSITION is specified the item ID is used.

    EnableMenuItem(hMenu, 1002, MF_BYCOMMAND | MF_GRAYED);

    uint WM_COMMAND = 0x0111;

nCmdShow is an integer type parameter specifying how the window is to be shown. See ShowWindowCommand