C#

anveshvm wrote:

Or should I connect to the database, each time, I have to execute a query?

anveshvm wrote:

Should I keep the object static for the entire program execution scope.

bool contains = con.Images.ToList().Contains(con.Images.First(n => n.imageID == 2),new checker());

public class checker : IEqualityComparer<image>
   {



       #region IEqualityComparer<image> Members

       public bool Equals(Image x, Image y)
       {
           if (x.imageID == y.imageID)
               return true;
           else
           {
               return false;
           }
       }

       public int GetHashCode(Image obj)
       {
           return obj.GetHashCode();
       }

       #endregion
   }</image></image>

Image myImg2 = new Image
                               {
                                   created = DateTime.Parse("23.05.2008 00:00:00"),
                                   description = "Jalla",
                                   imageID = 2,
                                   name = "test",
                                   searchWords = "halla",
                                   systemID = 1
                               };
            Image myImg4 = new Image
            {
                created = DateTime.Parse("23.05.2008 00:00:00"),
                description = "Jalla",
                imageID = 2,
                name = "test",
                searchWords = "halla",
                systemID = 1
            };

if (myImg2.Equals(myImg4))
                Console.WriteLine("hurra");

[Table(Name="dbo.Images")]
	public partial class Image
	{
		
		private int _imageID;
		
		private int _systemID;
		
		private string _name;
		
		private string _description;
		
		private string _searchWords;
		
		private System.DateTime _created;
		
		private System.Nullable<system.datetime> _uppdated;
		
		public Image()
		{
		}
		
		[Column(Storage="_imageID", AutoSync=AutoSync.Always, DbType="Int NOT NULL IDENTITY", IsDbGenerated=true)]
		public int imageID
		{
			get
			{
				return this._imageID;
			}
			set
			{
				if ((this._imageID != value))
				{
					this._imageID = value;
				}
			}
		}
		
		[Column(Storage="_systemID", DbType="Int NOT NULL")]
		public int systemID
		{
			get
			{
				return this._systemID;
			}
			set
			{
				if ((this._systemID != value))
				{
					this._systemID = value;
				}
			}
		}
		
		[Column(Storage="_name", DbType="NVarChar(50) NOT NULL", CanBeNull=false)]
		public string name
		{
			get
			{
				return this._name;
			}
			set
			{
				if ((this._name != value))
				{
					this._name = value;
				}
			}
		}
		
		[Column(Storage="_description", DbType="NVarChar(2000)")]
		public string description
		{
			get
			{
				return this._description;
			}
			set
			{
				if ((this._description != value))
				{
					this._description = value;
				}
			}
		}
		
		[Column(Storage="_searchWords", DbType="NVarChar(2000)")]
		public string searchWords
		{
			get
			{
				return this._searchWords;
			}
			set
			{
				if ((this._searchWords != value))
				{
					this._searchWords = value;
				}
			}
		}
		
		[Column(Storage="_created", DbType="DateTime NOT NULL")]
		public System.DateTime created
		{
			get
			{
				return this._created;
			}
			set
			{
				if ((this._created != value))
				{
					this._created = value;
				}
			}
		}
		
		[Column(Storage="_uppdated", DbType="DateTime")]
		public System.Nullable<system.datetime> uppdated
		{
			get
			{
				return this._uppdated;
			}
			set
			{
				if ((this._uppdated != value))
				{
					this._uppdated = value;
				}
			}
		}
	}</system.datetime></system.datetime>

Cyrilix wrote:

measure the retry count (the number of times it has to spin again because something changed)

Cyrilix wrote:

I'm curious to know the theory behind it.

public void Enqueue(T data)
{
    LockFreeQueueNode<T> tempTail = null;
    LockFreeQueueNode<T> tempTailNext = null;
    LockFreeQueueNode<T> newNode = new LockFreeQueueNode<T>(data);
    newNode.Data = data;
    do
    {
        tempTail = tail;
        tempTailNext = tempTail.NextNode;
        if (tempTail == tail)
        {
            if (tempTailNext == null)
            {
                // If the tail node we are referring to is really the last
                // node in the queue (i.e. its next node is null), then
                // try to point its next node to our new node
                //
                if (Interlocked.CompareExchange(ref tempTail.NextNode, newNode, tempTailNext) == tempTailNext)
                    break;
            }
            else
            {
                // This condition occurs when we have failed to update
                // the tail's next node. And the next time we try to update
                // the next node, the next node is pointing to a new node
                // updated by other thread. But the other thread has not yet
                // re-pointed the tail to its new node.
                // So we try to re-point to the tail node to the next node of the
                // current tail
                //
                Interlocked.CompareExchange(ref tail, tempTailNext, tempTail);
            }
        }
        Interlocked.Increment(ref retryCount);
    } while (true);

    // If we were able to successfully change the next node of the current tail node
    // to point to our new node, then re-point the tail node also to our new node
    //
    Interlocked.CompareExchange(ref tail, newNode, tempTail);
    Interlocked.Increment(ref count);
}