namespace OpcAbonniertesLesen
{
    using JetBrains.Annotations;
    using OpcLabs.EasyOpc.DataAccess;
    using OpcLabs.EasyOpc.DataAccess.OperationModel;
    using System;
    using System.Threading;
 
    internal class Program
    {
        private Program()
        {
            this.ItemNames = new[] {
                "a",
                "couple",
                "of",
                "items",
                "which",
                "exist",
                "on",
                "the",
                "production",
                "server"
            };
        }
 
        private static readonly Program instance = new Program();
 
        private static void Main(string[] args)
        {
            instance.DoWork();
        }
 
        private void DoWork()
        {
            this.easyDAClient.ItemChanged += this.EasyDAClient_ItemChanged;
 
            Console.WriteLine("Preparing arguments...");
 
            var argumentArray = new DAItemGroupArguments[this.TotalItems];
            for (var i = 0; i < this.TotalItems; i++)
            {
                argumentArray[i] = new DAItemGroupArguments("localhost", "Schneider-Aut.OFS.2", this.ItemNames[i], 50, null);
            }
 
            Console.WriteLine("Subscribing to {0} items...", this.TotalItems);
            this.easyDAClient.SubscribeMultipleItems(argumentArray);
 
            Console.WriteLine("Processing item changed events for 1 minute...");
            Thread.Sleep(60 * 1000);
 
            Console.WriteLine("Done...");
        }
 
        private void EasyDAClient_ItemChanged([NotNull] object sender, [NotNull] EasyDAItemChangedEventArgs e)
        {
            Console.WriteLine("{0}: {1}", e.Arguments.ItemDescriptor.ItemId, e.Vtq);
        }
 
        private int TotalItems { get => this.ItemNames == null ? 0 : this.ItemNames.Length; }
 
        private readonly string[] ItemNames;
 
        private readonly EasyDAClient easyDAClient = new EasyDAClient();
    }
}

namespace OpcGruppenlesen
{
	using System;
	using System.Diagnostics;
	using System.Threading;
	using OpcLabs.EasyOpc.DataAccess;
	using OpcLabs.EasyOpc.DataAccess.OperationModel;
 
	internal class Program
	{
		private Program()
		{
			this.ItemNames = new[] {
				"a",
				"couple",
				"of",
				"items",
				"which",
				"exist",
				"on",
				"the",
				"production",
				"server"
			};
		}
 
		private static readonly Program instance = new Program();
 
		private static void Main( string[] args )
		{
			instance.TimeMeasurements();
			Console.ReadKey();
		}
 
		private const int NumberOfGroups = 7;
		private int ItemsInGroup { get => this.TotalItems / NumberOfGroups; }
		private int TotalItems { get => this.ItemNames == null ? 0 : this.ItemNames.Length; }
		private readonly string[] ItemNames;
 
		private void TimeMeasurements()
		{
			// Make the measurements 10 times; note that first time the times might be longer.
			for( var i = 1; i <= 10; i++ )
			{
				// Pause - we do not want the component to use the values it has in memory
				Thread.Sleep( 2 * 1000 );
 
				// Read all items at once, and measure the time
				var stopwatch1 = new Stopwatch();
				stopwatch1.Start();
				this.ReadAllAtOnce();
				stopwatch1.Stop();
				Console.WriteLine( "ReadAllAtOnce has taken (milliseconds): {0}", stopwatch1.ElapsedMilliseconds );
 
				// Pause - we do not want the component to use the values it has in memory
				Thread.Sleep( 2 * 1000 );
 
				// Read items in groups, and measure the time
				var stopwatch2 = new Stopwatch();
				stopwatch2.Start();
				this.ReadInGroups();
				stopwatch2.Stop();
				Console.WriteLine( "ReadInGroups has taken (milliseconds): {0}", stopwatch2.ElapsedMilliseconds );
			}
		}
		// Read all items at once
		private void ReadAllAtOnce()
		{
			var easyDAClient = new EasyDAClient();
 
			// Create an array of item descriptors for all items
			var itemDescriptors = new DAItemDescriptor[this.TotalItems];
			var index = 0;
			for( var iLoop = 0; iLoop < NumberOfGroups; iLoop++ )
				for( var iItem = 0; iItem < this.ItemsInGroup; iItem++ )
					itemDescriptors[index++] = new DAItemDescriptor( this.ItemNames[iLoop * this.ItemsInGroup + iItem] );
 
			// Perform the OPC read
			var vtqResults = easyDAClient.ReadMultipleItems("Schneider-Aut.OFS.2", itemDescriptors);
 
			// Count successful results
			var successCount = 0;
			for( var iItem = 0; iItem < this.TotalItems; iItem++ )
			{
				Debug.Assert( vtqResults[iItem] != null );
				if( vtqResults[iItem].Succeeded )
					successCount++;
			}
 
			if( successCount != this.TotalItems )
				Console.WriteLine( "Warning: There were some failures, success count is {0}", successCount );
		}
 
		// Read items in groups
		private void ReadInGroups()
		{
			var easyDAClient = new EasyDAClient();
 
			var successCount = 0;
			for( var iLoop = 0; iLoop < NumberOfGroups; iLoop++ )
			{
				// Create an array of item descriptors for items in one group
				var itemDescriptors = new DAItemDescriptor[this.ItemsInGroup];
				for( var iItem = 0; iItem < this.ItemsInGroup; iItem++ )
					itemDescriptors[iItem] = new DAItemDescriptor( this.ItemNames[iLoop * this.ItemsInGroup + iItem] );
 
				// Perform the OPC read
				var vtqResults = easyDAClient.ReadMultipleItems("Schneider-Aut.OFS.2", itemDescriptors);
 
				// Count successful results (totalling to previous value)
				for( var iItem = 0; iItem < this.ItemsInGroup; iItem++ )
				{
					Debug.Assert( vtqResults[iItem] != null );
					if( vtqResults[iItem].Succeeded ) successCount++;
				}
			}
 
			if( successCount != this.TotalItems )
				Console.WriteLine( "Warning: There were some failures, success count is {0}", successCount );
		}
	}
}