YG-OPP-WCS/WCS.Core/EntityEx.cs

using System;
using System.Collections.Generic;
using System.Linq;
using WCS.Entity;

namespace WCS.Core
{
    public abstract class EntityEx<T>
    {
        public T Entity
        {
            get; private set;
        }

        /// <summary>
        /// 执行中的设备
        /// </summary>
        public static List<string> ExDevice { get; set; } = new List<string>();

        /// <summary>
        /// 添加锁
        /// </summary>
        private static readonly object Addobj = new object();

        /// <summary>
        /// 移除锁
        /// </summary>
        private static readonly object removeobj = new object();

        /// <summary>
        /// 添加进行中的设备
        /// </summary>
        /// <param name="e"></param>
        public void AddExDevice(string e)
        {
            //lock (Addobj)
            //{
                ExDevice.Add(e);
            //}
        }

        /// <summary>
        /// 移除进行中的设备
        /// </summary>
        /// <param name="e"></param>
        public void RemoveExDevice(string e)
        {
            //lock (removeobj)
            //{
                ExDevice.Remove(e);
            //}
        }

        public EntityEx(T entity)
        {
            this.Entity = entity;
        }

        public virtual DateTime UpdateTime { get; set; }

        public double Times
        {
            get
            {
                return (DateTime.Now - UpdateTime).TotalMilliseconds;
            }
        }

        public override string ToString()
        {
            return Entity.ToString();
        }
    }

    public class Device<T> : EntityEx<WCS_DEVICE> where T : IProtocol
    {
        public T Data { get; private set; }

        public Device(WCS_DEVICE entity) : base(entity)
        {
            Data = entity.PROTOCOLS.Where(v => v.DB.PROTOCOL == typeof(T).AssemblyQualifiedName).Single().Data<T>();
        }
    }

    public class Device<T, T2> : Device<T> where T : IProtocol where T2 : IProtocol
    {
        public T2 Data2 { get; private set; }

        public Device(WCS_DEVICE entity) : base(entity)
        {
            Data2 = entity.PROTOCOLS.Where(v => v.DB.PROTOCOL == typeof(T2).AssemblyQualifiedName).Single().Data<T2>();
        }
    }

    public class Device<T, T2, T3> : Device<T, T2> where T : IProtocol where T2 : IProtocol where T3 : IProtocol
    {
        public T3 Data3 { get; private set; }

        public Device(WCS_DEVICE entity) : base(entity)
        {
            Data3 = entity.PROTOCOLS.Where(v => v.DB.PROTOCOL == typeof(T3).AssemblyQualifiedName).Single().Data<T3>();
        }
    }

    public class Device<T, T2, T3, T4> : Device<T, T2, T3> where T : IProtocol where T2 : IProtocol where T3 : IProtocol where T4 : IProtocol
    {
        public T4 Data4 { get; private set; }

        public Device(WCS_DEVICE entity) : base(entity)
        {
            Data4 = entity.PROTOCOLS.Where(v => v.DB.PROTOCOL == typeof(T4).AssemblyQualifiedName).Single().Data<T4>();
        }
    }

    public class Group<T> : EntityEx<WCS_DEVICE> where T : EntityEx<WCS_DEVICE>
    {
        public IEnumerable<T> Items { get; private set; }

        public Group(WCS_DEVICE entity) : base(entity)
        {
            Items = entity.DEVICEGROUP.Select(v => Activator.CreateInstance(typeof(T), v.MEMBER)).OfType<T>().OrderBy(p => p.Entity.CODE).ToList();
        }
    }

    public class DeviceGroup<T> : Group<Device<T>> where T : IProtocol
    {
        public DeviceGroup(WCS_DEVICE entity) : base(entity)
        {
        }
    }

    public class DeviceGroup<T, T2> : Group<Device<T, T2>> where T : IProtocol where T2 : IProtocol
    {
        public DeviceGroup(WCS_DEVICE entity) : base(entity)
        {
        }
    }

    public class DeviceGroup<T, T2, T3> : Group<Device<T, T2, T3>> where T : IProtocol where T2 : IProtocol where T3 : IProtocol
    {
        public DeviceGroup(WCS_DEVICE entity) : base(entity)
        {
        }
    }
}