CODEWITHSUNDEEP
c#.net
sri
sri

Reputation: 1005

new instance of Object()

I came across this definition of Object constructor (metadata from mscorlib.dll)

[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
public Object();

I didn't understood what ConstrainedExecution (Cer.MayFail) mean can someone tell me with an example in this case.

I came across this code, also tell me if it is correct to write like this,

public class MyClass
{
    private static object instanceLock = new object();

    private void Func()
    {
        bool instanceLockTaken = false;

        Monitor.TryEnter(instanceLock, ref instanceLockTaken);
        //...
        Monitor.Exit(instanceLock);
    }
}

Upvotes: 2

Views: 165

Answers (4)

undefined
undefined

Reputation: 1364

So, generally speaking, you have 2 questions here.

1) Reliability contracts is a tool used by CLR team to support constrained execution regions. It is an advanced topic, but simply speaking the construction describes if a function (or a constructor) can fail, and if yes, what impact will be ( no impact, appDomain impact, process impact, whole machine crush, etc)

2) Your code snippet is incorrect. Why do you saving instanceLockTaken if you are not going to check it further? Furthermore, if exception occur between the lock acquisition and releasing it, you'll leak the lock. Consider using the lock statement, which is syntax sugar for something like this:

    bool instanceLockTaken = false;
    try
    {
      Monitor.Enter(instanceLock, ref instanceLockTaken);

    //...
    }
    finally
    {
      if (instanceLockTaken) 
      {
         Monitor.Exit(instanceLock);
      }
    }

Upvotes: 2

IvoTops
IvoTops

Reputation: 3531

This is the correct way for Monitor locking;

bool isLocked = false;
try
{
 Monitor.Enter(instanceLock , ref isLocked);
 // Do some things within the lock    
}
finally
{
 if (isLocked) Monitor.Exit(instanceLock);
}

As for cer.mayfail this link will provide some more information http://weblogs.asp.net/justin_rogers/archive/2004/10/05/238275.aspx

Upvotes: 0

daryal
daryal

Reputation: 14919

Cer.Mayfail keyword implies that if the marked method throws an exception, the data may be in an invalid state; the previous state of the object will not be restored.

Upvotes: 0

greg84
greg84

Reputation: 7599

Constrained Execution is what you're trying to achieve by locking the thread.

From: http://msdn.microsoft.com/en-us/magazine/cc163716.aspx

A Cer value of MayFail is used to signal that when faced with asynchronous exceptions, the code may not complete in an expected fashion. Since thread aborts are being delayed over constrained execution regions, this really means that your code is doing something that may cause memory to be allocated or that might result in a stack overflow. More importantly, it means that you must take the possible failures into consideration when calling this method.

In your case, because the object is static and only created once, this will not be a problem.

Monitor.TryEnter returns immediately even if a lock was not acquired. It has a boolean value, which you're not checking, something like this would work:

Monitor.TryEnter(instanceLock, ref instanceLockTaken);

  if (instanceLockTaken) 
  {
    // Do stuff here

    Monitor.Exit(instanceLock);
  }

However, this code would mean that the if {} block would not be executed every time, if you want to acquire a lock on every thread, you'll need to do something like this:

lock(instanceLock)
{
  // Do stuff here
}

This means that only a single thread can run the contents of the lock {} statement at a time, and the contents of the lock statement will be executed every time.

On a side note, you can also make the object you're locking readonly:

private static readonly object instanceLock = new object();

Upvotes: 4

Related Questions