Get a reference to the current process and use `System.Diagnostics`&#39;s `Process.Id` property:

    int nProcessID = Process.GetCurrentProcess().Id;

    Process.GetCurrentProcess().Id

Or, since the `Process` class is `IDisposable`, and the Process ID isn&#39;t going to change while your application&#39;s running, you could have a helper class with a static property:

    public static int ProcessId
    {
		get 
		{
			if (_processId == null)
			{
				using(var thisProcess = System.Diagnostics.Process.GetCurrentProcess())
				{
					_processId = thisProcess.Id;
				}
			}
			return _processId.Value;
		}
    }
    private static int? _processId;


The upcoming .NET 5 introduces `Environment.ProcessId` which should be preferred over `Process.GetCurrentProcess().Id` as it avoids allocations and the need to dispose the Process object.

https://devblogs.microsoft.com/dotnet/performance-improvements-in-net-5/ shows a benchmark where `Environment.ProcessId` only takes 3ns instead of 68ns with `Process.GetCurrentProcess().Id`.

When my paid developer membership runs out with Apple, what happens to my existing apps on the app store?

I know that I cannot add new apps then, but do my existing apps stay? Can I change prices? Can I get paid for sales? Can I update those apps? (Am I missing any questions here?)

What happens to my apps after my developer account membership expires?

Many tools/APIs provide ways of selecting elements of specific classes or IDs. There&#39;s also possible to inspect the raw stylesheets loaded by the browser.

However, for browsers to render an element, they&#39;ll compile all CSS rules (possibly from different stylesheet files) and apply it to the element. This is what you see with Firebug or the WebKit Inspector - the full CSS inheritance tree for an element.

How can I reproduce this feature in pure JavaScript without requiring additional browser plugins?


Perhaps an example can provide some clarification for what I&#39;m looking for:

    &lt;style type=&quot;text/css&quot;&gt;
        p { color :red; }
        #description { font-size: 20px; }
    &lt;/style&gt;

    &lt;p id=&quot;description&quot;&gt;Lorem ipsum&lt;/p&gt;

Here the p#description element have two CSS rules applied: a red color and a font size of 20 px.

I would like to find the source from where these computed CSS rules originate from (color comes the p rule and so on).





Find all CSS rules that apply to an element

What&#39;s the simplest way to obtain the current process ID from within your own application, using the .NET Framework?

How to get the current ProcessID?

<p>What's the simplest way to obtain the current process ID from within your own application, using the .NET Framework?</p>


What&#39;s the difference between **`Console`**`.WriteLine()` vs **`Debug`**`.WriteLine()`?

What&#39;s the difference between Console.WriteLine() vs Debug.WriteLine()?

what is IEnumerable in .net

With the addition of the [Tuple][1] class in .net 4, I have been trying to decide if using them in my design is a bad choice or not.  The way I see it, a [Tuple][1] can be a shortcut to writing a result class (I am sure there are other uses too).  

So this:

    public class ResultType
    {
        public string StringValue { get; set; }
        public int IntValue { get; set; }
    }

    public ResultType GetAClassedValue()
    {
        //..Do Some Stuff
        ResultType result = new ResultType { StringValue = &quot;A String&quot;, IntValue = 2 };
        return result;
    }
    
Is equivalent to this:

    public Tuple&lt;string, int&gt; GetATupledValue()
    {
        //...Do Some stuff
        Tuple&lt;string, int&gt; result = new Tuple&lt;string, int&gt;(&quot;A String&quot;, 2);
        return result;
    }

So setting aside the possibility that I am missing the point of Tuples, is the example with a [Tuple][1] a bad design choice?  To me it seems like less clutter, but not as self documenting and clean.  Meaning that with the type `ResultType`, it is very clear later on what each part of the class means but you have extra code to maintain.  With the `Tuple&lt;string, int&gt;` you will need to look up and figure out what each `Item` represents, but you write and maintain less code.

Any experience you have had with this choice would be greatly appreciated.

  [1]: http://msdn.microsoft.com/en-us/library/system.tuple.aspx



Is Using .NET 4.0 Tuples in my C# Code a Poor Design Decision?

### Background

While running benchmark tests this morning, my colleagues and I discovered some strange things concerning performance of C# code vs. VB.NET code.

We started out comparing C# vs. Delphi Prism calculating prime numbers, and found that Prism was about 30% faster. I figured CodeGear optimized code more when generating IL (the `exe` was about twice as big as C#&#39;s and had all sorts of different IL in it.) 

I decided to write a test in VB.NET as well, assuming that Microsoft&#39;s compilers would end up writing essentially the same IL for each language. However, the result there was more shocking: **the code ran more than three times slower on C# than VB with the same operation!** 

The generated IL was different, but not extremely so, and I&#39;m not good enough at reading it to understand the differences.

### Benchmarks

I&#39;ve included the code for each below. On my machine, VB finds 348513 primes in about **6.36** seconds. C# finds the same number of primes in **21.76** seconds. 

### Computer Specs and Notes
 
 - Intel Core 2 Quad 6600 @ 2.4Ghz

Every machine I&#39;ve tested on there is a noticeable difference in the benchmark results between C# and VB.NET.

Both of the console applications were compiled in Release mode, but otherwise no project settings were changed from the defaults generated by Visual Studio 2008.

### VB.NET code

&lt;!-- language: lang-vb.net --&gt;

    Imports System.Diagnostics

    Module Module1

        Private temp As List(Of Int32)
        Private sw As Stopwatch
        Private totalSeconds As Double

        Sub Main()
            serialCalc()
        End Sub

        Private Sub serialCalc()
            temp = New List(Of Int32)()
            sw = Stopwatch.StartNew()
            For i As Int32 = 2 To 5000000
                testIfPrimeSerial(i)
            Next
            sw.Stop()
            totalSeconds = sw.Elapsed.TotalSeconds
            Console.WriteLine(String.Format(&quot;{0} seconds elapsed.&quot;, totalSeconds))
            Console.WriteLine(String.Format(&quot;{0} primes found.&quot;, temp.Count))
            Console.ReadKey()
        End Sub

        Private Sub testIfPrimeSerial(ByVal suspectPrime As Int32)
            For i As Int32 = 2 To Math.Sqrt(suspectPrime)
                If (suspectPrime Mod i = 0) Then
                    Exit Sub
                End If
            Next
            temp.Add(suspectPrime)
        End Sub

    End Module

### C# Code

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Diagnostics;

    namespace FindPrimesCSharp {
        class Program {
            List&lt;Int32&gt; temp = new List&lt;Int32&gt;();
            Stopwatch sw;
            double totalSeconds;


            static void Main(string[] args) {

                new Program().serialCalc();

            }


            private void serialCalc() {
                temp = new List&lt;Int32&gt;();
                sw = Stopwatch.StartNew();
                for (Int32 i = 2; i &lt;= 5000000; i++) {
                    testIfPrimeSerial(i);
                }
                sw.Stop();
                totalSeconds = sw.Elapsed.TotalSeconds;
                Console.WriteLine(string.Format(&quot;{0} seconds elapsed.&quot;, totalSeconds));
                Console.WriteLine(string.Format(&quot;{0} primes found.&quot;, temp.Count));
                Console.ReadKey();
            }

            private void testIfPrimeSerial(Int32 suspectPrime) {
                for (Int32 i = 2; i &lt;= Math.Sqrt(suspectPrime); i++) {
                    if (suspectPrime % i == 0)
                        return;
                }
                temp.Add(suspectPrime);
            }

        }
    }


Why is C#&#39;s execution of `Math.Sqrt()` slower than VB.NET?

Why does C# execute Math.Sqrt() more slowly than VB.NET?

Inspired by an SO question.  The Attribute class has several overloads for the [IsDefined()][1] method. Covered are attributes applied to Assembly, Module, MemberInfo, ParameterInfo.  The MemberInfo overload covers PropertyInfo, FieldInfo, EventInfo, MethodInfo, ConstructorInfo.

That takes care of most of the AttributeTargets.  Except for one biggy: there is no overload for Attribute.IsDefined(Type, Type) so that you could check if an attribute is defined on a class.  Or a struct, delegate or enum for that matter.

Not that this is a real problem, Type.GetCustomAttributes() can fix that.  But all of the BlahInfo types have this too.  I wonder at the lack of symmetry.  I can&#39;t put a finger on why this would be problem for Type.  Guessing at an inheritance problem doesn&#39;t explain it to me.  Having ValueType in the mix might be a lead, still doesn&#39;t make sense.  I don&#39;t buy &quot;they forgot&quot;, they never do.

Why is this overload missing?


  [1]: http://msdn.microsoft.com/en-us/library/system.attribute.isdefined%28VS.85%29.aspx

Why is Attributes.IsDefined() missing overloads?

What is the difference between a thread/process/task?

In a bash script, I want to do the following (in pseudo-code):

    if [ a process exists with $PID ]; then
       
        kill $PID 
       
    fi

What&#39;s the appropriate expression for the conditional statement?

How to check if a process id (PID) exists

I&#39;ve an application which does

    Process.Start()

to start another application &#39;ABC&#39;. I want to wait till that application ends (process dies) and continue my execution. How can I do it?

There may be multiple instances of the application &#39;ABC&#39; running at the same time.


Wait until a process ends

I&#39;m reading up on concurrency.  I&#39;ve got a bit over my head with terms that have confusingly similar definitions.  Namely:

* Processes
* Threads
* &quot;Green threads&quot;
* Protothreads
* Fibers
* Coroutines
* &quot;Goroutines&quot; in the Go language

My impression is that the distinctions rest on (1) whether truly parallel or multiplexed; (2) whether managed at the CPU, at the OS, or in the program; and (3..5) a few other things I can&#39;t identify.

Is there a succinct and unambiguous guide to the differences between these approaches to parallelism?

Processes, threads, green threads, protothreads, fibers, coroutines: what&#39;s the difference?

I&#39;m creating new processes using `System.Diagnostics.Process` class from my application.&lt;br&gt;&lt;br&gt; I want this processes to be killed when/if my application has crashed. But if I kill my application from Task Manager, child processes are not killed.&lt;br&gt;&lt;br&gt; Is there any way to make child processes dependent on parent process?

Content Type	Original Author	Original Content on Stackoverflow
Question	plaureano	View Question on Stackoverflow
Solution 1 - .Net	luvieere	View Answer on Stackoverflow
Solution 2 - .Net	Joe	View Answer on Stackoverflow
Solution 3 - .Net	ckuri	View Answer on Stackoverflow

How to get the current ProcessID?

.Net Problem Overview

.Net Solutions

Solution 1 - .Net

Solution 2 - .Net

Solution 3 - .Net

Find all CSS rules that apply to an element

What happens to my apps after my developer account membership expires?

Attributions