mcs/class/System/System.Diagnostics/Process.cs

   1 //
   2 // System.Diagnostics.Process.cs
   3 //
   4 // Authors:
   5 //   Dick Porter (dick@ximian.com)
   6 //
   7 // (C) 2002 Ximian, Inc.
   8 //
   9
  10 using System;
  11 using System.IO;
  12 using System.ComponentModel;
  13
  14 namespace System.Diagnostics {
  15         public class Process : Component {
  16                 [MonoTODO]
  17                 public Process() {
  18                 }
  19
  20                 [MonoTODO]
  21                 public int BasePriority {
  22                         get {
  23                                 return(0);
  24                         }
  25                 }
  26
  27                 [MonoTODO]
  28                 public bool EnableRaisingEvents {
  29                         get {
  30                                 return(false);
  31                         }
  32                         set {
  33                         }
  34                 }
  35
  36                 [MonoTODO]
  37                 public int ExitCode {
  38                         get {
  39                                 return(0);
  40                         }
  41                 }
  42
  43                 [MonoTODO]
  44                 public DateTime ExitTime {
  45                         get {
  46                                 return(new DateTime(0));
  47                         }
  48                 }
  49
  50                 [MonoTODO]
  51                 public IntPtr Handle {
  52                         get {
  53                                 return((IntPtr)0);
  54                         }
  55                 }
  56
  57                 [MonoTODO]
  58                 public int HandleCount {
  59                         get {
  60                                 return(0);
  61                         }
  62                 }
  63
  64                 [MonoTODO]
  65                 public bool HasExited {
  66                         get {
  67                                 return(false);
  68                         }
  69                 }
  70
  71                 [MonoTODO]
  72                 public int Id {
  73                         get {
  74                                 return(0);
  75                         }
  76                 }
  77
  78                 [MonoTODO]
  79                 public string MachineName {
  80                         get {
  81                                 return("localhost");
  82                         }
  83                 }
  84
  85                 [MonoTODO]
  86                 public ProcessModule MainModule {
  87                         get {
  88                                 return(null);
  89                         }
  90                 }
  91
  92                 [MonoTODO]
  93                 public IntPtr MainWindowHandle {
  94                         get {
  95                                 return((IntPtr)0);
  96                         }
  97                 }
  98
  99                 [MonoTODO]
 100                 public string MainWindowTitle {
 101                         get {
 102                                 return("null");
 103                         }
 104                 }
 105
 106                 [MonoTODO]
 107                 public IntPtr MaxWorkingSet {
 108                         get {
 109                                 return((IntPtr)0);
 110                         }
 111                         set {
 112                         }
 113                 }
 114
 115                 [MonoTODO]
 116                 public IntPtr MinWorkingSet {
 117                         get {
 118                                 return((IntPtr)0);
 119                         }
 120                         set {
 121                         }
 122                 }
 123
 124                 [MonoTODO]
 125                 public ProcessModuleCollection Modules {
 126                         get {
 127                                 return(null);
 128                         }
 129                 }
 130
 131                 [MonoTODO]
 132                 public int NonpagedSystemMemorySize {
 133                         get {
 134                                 return(0);
 135                         }
 136                 }
 137
 138                 [MonoTODO]
 139                 public int PagedMemorySize {
 140                         get {
 141                                 return(0);
 142                         }
 143                 }
 144
 145                 [MonoTODO]
 146                 public int PagedSystemMemorySize {
 147                         get {
 148                                 return(0);
 149                         }
 150                 }
 151
 152                 [MonoTODO]
 153                 public int PeakPagedMemorySize {
 154                         get {
 155                                 return(0);
 156                         }
 157                 }
 158
 159                 [MonoTODO]
 160                 public int PeakVirtualMemorySize {
 161                         get {
 162                                 return(0);
 163                         }
 164                 }
 165
 166                 [MonoTODO]
 167                 public int PeakWorkingSet {
 168                         get {
 169                                 return(0);
 170                         }
 171                 }
 172
 173                 [MonoTODO]
 174                 public bool PriorityBoostEnabled {
 175                         get {
 176                                 return(false);
 177                         }
 178                         set {
 179                         }
 180                 }
 181
 182                 [MonoTODO]
 183                 public ProcessPriorityClass PriorityClass {
 184                         get {
 185                                 return(ProcessPriorityClass.Normal);
 186                         }
 187                         set {
 188                         }
 189                 }
 190
 191                 [MonoTODO]
 192                 public int PrivateMemorySize {
 193                         get {
 194                                 return(0);
 195                         }
 196                 }
 197
 198                 [MonoTODO]
 199                 public TimeSpan PrivilegedProcessorTime {
 200                         get {
 201                                 return(new TimeSpan(0));
 202                         }
 203                 }
 204
 205                 [MonoTODO]
 206                 public string ProcessName {
 207                         get {
 208                                 return("this-process");
 209                         }
 210                 }
 211
 212                 [MonoTODO]
 213                 public IntPtr ProcessorAffinity {
 214                         get {
 215                                 return((IntPtr)0);
 216                         }
 217                         set {
 218                         }
 219                 }
 220
 221                 [MonoTODO]
 222                 public bool Responding {
 223                         get {
 224                                 return(false);
 225                         }
 226                 }
 227
 228                 [MonoTODO]
 229                 public StreamReader StandardError {
 230                         get {
 231                                 return(null);
 232                         }
 233                 }
 234
 235                 [MonoTODO]
 236                 public StreamWriter StandardInput {
 237                         get {
 238                                 return(null);
 239                         }
 240                 }
 241
 242                 [MonoTODO]
 243                 public StreamReader StandardOutput {
 244                         get {
 245                                 return(null);
 246                         }
 247                 }
 248
 249                 [MonoTODO]
 250                 public ProcessStartInfo StartInfo {
 251                         get {
 252                                 return(null);
 253                         }
 254                         set {
 255                         }
 256                 }
 257
 258                 [MonoTODO]
 259                 public DateTime StartTime {
 260                         get {
 261                                 return(new DateTime(0));
 262                         }
 263                 }
 264
 265                 [MonoTODO]
 266                 public ISynchronizeInvoke SynchronizingObject {
 267                         get {
 268                                 return(null);
 269                         }
 270                         set {
 271                         }
 272                 }
 273
 274                 [MonoTODO]
 275                 public ProcessThreadCollection Threads {
 276                         get {
 277                                 return(null);
 278                         }
 279                 }
 280
 281                 [MonoTODO]
 282                 public TimeSpan TotalProcessorTime {
 283                         get {
 284                                 return(new TimeSpan(0));
 285                         }
 286                 }
 287
 288                 [MonoTODO]
 289                 public TimeSpan UserProcessorTime {
 290                         get {
 291                                 return(new TimeSpan(0));
 292                         }
 293                 }
 294
 295                 [MonoTODO]
 296                 public int VirtualMemorySize {
 297                         get {
 298                                 return(0);
 299                         }
 300                 }
 301
 302                 [MonoTODO]
 303                 public int WorkingSet {
 304                         get {
 305                                 return(0);
 306                         }
 307                 }
 308
 309                 [MonoTODO]
 310                 public void Close() {
 311                 }
 312
 313                 [MonoTODO]
 314                 public bool CloseMainWindow() {
 315                         return(false);
 316                 }
 317
 318                 [MonoTODO]
 319                 public static void EnterDebugMode() {
 320                 }
 321
 322                 [MonoTODO]
 323                 public static Process GetCurrentProcess() {
 324                         return(null);
 325                 }
 326
 327                 [MonoTODO]
 328                 public static Process GetProcessById(int processId) {
 329                         return(null);
 330                 }
 331
 332                 [MonoTODO]
 333                 public static Process GetProcessById(int processId, string machineName) {
 334                         return(null);
 335                 }
 336
 337                 [MonoTODO]
 338                 public static Process[] GetProcesses() {
 339                         return(null);
 340                 }
 341
 342                 [MonoTODO]
 343                 public static Process[] GetProcesses(string machineName) {
 344                         return(null);
 345                 }
 346
 347                 [MonoTODO]
 348                 public static Process[] GetProcessesByName(string processName) {
 349                         return(null);
 350                 }
 351
 352                 [MonoTODO]
 353                 public static Process[] GetProcessesByName(string processName, string machineName) {
 354                         return(null);
 355                 }
 356
 357                 [MonoTODO]
 358                 public void Kill() {
 359                 }
 360
 361                 [MonoTODO]
 362                 public static void LeaveDebugMode() {
 363                 }
 364
 365                 [MonoTODO]
 366                 public void Refresh() {
 367                 }
 368
 369                 [MonoTODO]
 370                 public bool Start() {
 371                         return(false);
 372                 }
 373
 374                 [MonoTODO]
 375                 public static Process Start(ProcessStartInfo startInfo) {
 376                         return(null);
 377                 }
 378
 379                 [MonoTODO]
 380                 public static Process Start(string fileName) {
 381                         return(null);
 382                 }
 383
 384                 [MonoTODO]
 385                 public static Process Start(string fileName, string arguments) {
 386                         return(null);
 387                 }
 388
 389                 [MonoTODO]
 390                 public override string ToString() {
 391                         return("process name");
 392                 }
 393
 394                 [MonoTODO]
 395                 public void WaitForExit() {
 396                 }
 397
 398                 [MonoTODO]
 399                 public bool WaitForExit(int milliseconds) {
 400                         return(false);
 401                 }
 402
 403                 [MonoTODO]
 404                 public bool WaitForInputIdle() {
 405                         return(false);
 406                 }
 407
 408                 [MonoTODO]
 409                 public bool WaitForInputIdle(int milliseconds) {
 410                         return(false);
 411                 }
 412
 413                 [MonoTODO]
 414                 public event EventHandler Exited;
 415
 416                 [MonoTODO]
 417                 protected override void Dispose(bool disposing) {
 418                 }
 419
 420                 [MonoTODO]
 421                 public override void Dispose() {
 422                 }
 423
 424                 [MonoTODO]
 425                 protected void OnExited() {
 426                 }
 427         }
 428 }
 429