public System.Collections.Generic.List <Model.LinkageConfigMixed> Create(int amount)
        {
            List <LinkageConfigMixed> lstLinkageConfigMixed = new List <LinkageConfigMixed>();

            //int currentMaxCode = GetMaxCode();
            if (DataRecordAlreadySet)
            {
                _maxCode = GetMaxCode();
                _maxID   = GetMaxID();
            }
            int tempCode = _maxCode;

            if (tempCode >= MaxMixedLinkageConfigAmount)
            {
                amount = 0;
            }
            else
            {
                if ((tempCode + amount) > MaxMixedLinkageConfigAmount) //如果需要添加的行数将达上限,则增加剩余的行数
                {
                    amount = MaxMixedLinkageConfigAmount - tempCode;
                }
                for (int i = 0; i < amount; i++)
                {
                    //currentMaxCode++;
                    tempCode++;
                    _maxID++;
                    LinkageConfigMixed lcm = new LinkageConfigMixed();
                    lcm.Controller   = _controller;
                    lcm.ControllerID = _controller.ID;
                    lcm.ActionType   = LinkageActionType.AND;
                    lcm.TypeA        = LinkageType.ZoneLayer;
                    lcm.TypeB        = LinkageType.ZoneLayer;
                    lcm.TypeC        = LinkageType.ZoneLayer;
                    lcm.ID           = _maxID;
                    lcm.Code         = tempCode.ToString().PadLeft(MaxMixedLinkageConfigAmount.ToString().Length, '0');
                    lcm.IsDirty      = true;
                    lstLinkageConfigMixed.Add(lcm);
                }
                _maxCode             = tempCode;
                DataRecordAlreadySet = false;
                foreach (var singleItem in lstLinkageConfigMixed)
                {
                    Update(singleItem);
                }
            }
            return(lstLinkageConfigMixed);
        }
 public bool DeleteBySpecifiedID(int id)
 {
     try
     {
         var result           = from lcm in _controller.MixedConfig where lcm.ID == id select lcm;
         LinkageConfigMixed o = result.FirstOrDefault();
         if (o != null)
         {
             _controller.MixedConfig.Remove(o);
         }
     }
     catch
     {
         return(false);
     }
     return(true);
 }
        public LinkageConfigMixed ToLinkageConfigMixed()
        {
            LinkageConfigMixed linkageConfigMixed = new LinkageConfigMixed();

            linkageConfigMixed.Controller        = this.Controller;
            linkageConfigMixed.ControllerID      = this.ControllerID;
            linkageConfigMixed.ID                = this.ID;
            linkageConfigMixed.Code              = this.Code;
            linkageConfigMixed.ActionCoefficient = this.ActionCoefficient;
            linkageConfigMixed.ActionType        = this.ActionType;
            //分类A
            linkageConfigMixed.TypeA = this.TypeA;
            //回路A
            //器件编号A [当分类为“地址”时,存储的"回路编号"]
            linkageConfigMixed.LoopNoA = this.LoopNoA;
            //器件编号A [当分类为“地址”时,存储的"器件编号"]
            linkageConfigMixed.DeviceCodeA = this.DeviceCodeA;
            linkageConfigMixed.CategoryA   = this.CategoryA;
            //楼号A
            linkageConfigMixed.BuildingNoA = this.BuildingNoA;
            //区号A
            linkageConfigMixed.ZoneNoA = this.ZoneNoA;
            //层号A
            linkageConfigMixed.LayerNoA = this.LayerNoA;
            //器件类型A
            linkageConfigMixed.DeviceTypeCodeA = this.DeviceTypeCodeA;
            linkageConfigMixed.TypeB           = this.TypeB;
            linkageConfigMixed.LoopNoB         = this.LoopNoB;
            linkageConfigMixed.DeviceCodeB     = this.DeviceCodeB;
            linkageConfigMixed.CategoryB       = this.CategoryB;
            linkageConfigMixed.BuildingNoB     = this.BuildingNoB;
            linkageConfigMixed.ZoneNoB         = this.ZoneNoB;
            linkageConfigMixed.LayerNoB        = this.LayerNoB;
            linkageConfigMixed.DeviceTypeCodeB = this.DeviceTypeCodeB;
            linkageConfigMixed.TypeC           = this.TypeC;
            linkageConfigMixed.MachineNoC      = this.MachineNoC;
            linkageConfigMixed.LoopNoC         = this.LoopNoC;
            linkageConfigMixed.DeviceCodeC     = this.DeviceCodeC;
            linkageConfigMixed.BuildingNoC     = this.BuildingNoC;
            linkageConfigMixed.ZoneNoC         = this.ZoneNoC;
            linkageConfigMixed.LayerNoC        = this.LayerNoC;
            linkageConfigMixed.DeviceTypeCodeC = this.DeviceTypeCodeC;
            return(linkageConfigMixed);
        }
 public EditableLinkageConfigMixed(LinkageConfigMixed linkageConfigMixed)
 {
     this.Controller        = linkageConfigMixed.Controller;
     this.ControllerID      = linkageConfigMixed.ControllerID;
     this.ID                = linkageConfigMixed.ID;
     this.Code              = linkageConfigMixed.Code;
     this.ActionCoefficient = linkageConfigMixed.ActionCoefficient;
     this.ActionType        = linkageConfigMixed.ActionType;
     //分类A
     this.TypeA = linkageConfigMixed.TypeA;
     //回路A
     //器件编号A [当分类为“地址”时,存储的"回路编号"]
     this.LoopNoA = linkageConfigMixed.LoopNoA;
     //器件编号A [当分类为“地址”时,存储的"器件编号"]
     this.DeviceCodeA = linkageConfigMixed.DeviceCodeA;
     this.CategoryA   = linkageConfigMixed.CategoryA;
     //楼号A
     this.BuildingNoA = linkageConfigMixed.BuildingNoA;
     //区号A
     this.ZoneNoA = linkageConfigMixed.ZoneNoA;
     //层号A
     this.LayerNoA = linkageConfigMixed.LayerNoA;
     //器件类型A
     this.DeviceTypeCodeA = linkageConfigMixed.DeviceTypeCodeA;
     this.TypeB           = linkageConfigMixed.TypeB;
     this.LoopNoB         = linkageConfigMixed.LoopNoB;
     this.DeviceCodeB     = linkageConfigMixed.DeviceCodeB;
     this.CategoryB       = linkageConfigMixed.CategoryB;
     this.BuildingNoB     = linkageConfigMixed.BuildingNoB;
     this.ZoneNoB         = linkageConfigMixed.ZoneNoB;
     this.LayerNoB        = linkageConfigMixed.LayerNoB;
     this.DeviceTypeCodeB = linkageConfigMixed.DeviceTypeCodeB;
     this.TypeC           = linkageConfigMixed.TypeC;
     this.MachineNoC      = linkageConfigMixed.MachineNoC;
     this.LoopNoC         = linkageConfigMixed.LoopNoC;
     this.DeviceCodeC     = linkageConfigMixed.DeviceCodeC;
     this.BuildingNoC     = linkageConfigMixed.BuildingNoC;
     this.ZoneNoC         = linkageConfigMixed.ZoneNoC;
     this.LayerNoC        = linkageConfigMixed.LayerNoC;
     this.DeviceTypeCodeC = linkageConfigMixed.DeviceTypeCodeC;
     ToCategoryString();
 }
Beispiel #5
0
        public List <LinkageConfigMixed> GetMixedLinkageConfigInfo(Model.ControllerModel controller)
        {
            List <LinkageConfigMixed> lstData    = new List <LinkageConfigMixed>();
            StringBuilder             sbQuerySQL = new StringBuilder("select ID,Code, ActionCoefficient,ActionType, TypeA, LoopNoA, DeviceCodeA ,BuildingNoA,ZoneNoA , LayerNoA , DeviceTypeCodeA,TypeB,LoopNoB,DeviceCodeB,BuildingNoB ,ZoneNoB , LayerNoB , DeviceTypeCodeB  ,TypeC ,MachineNoC,LoopNoC ,DeviceCodeC ,BuildingNoC ,ZoneNoC , LayerNoC  ,DeviceTypeCodeC  ,controllerID from LinkageConfigMixed where controllerID=" + controller.ID);

            System.Data.DataTable dt = _databaseService.GetDataTableBySQL(sbQuerySQL);
            for (int i = 0; i < dt.Rows.Count; i++)
            {
                LinkageConfigMixed model = new LinkageConfigMixed();
                model.ID   = Convert.ToInt32(dt.Rows[i]["ID"]);
                model.Code = dt.Rows[i]["Code"].ToString();
                model.ActionCoefficient = Convert.ToInt32(dt.Rows[i]["ActionCoefficient"]);
                model.ActionType        = (LinkageActionType)Enum.ToObject(typeof(LinkageActionType), Convert.ToInt16(dt.Rows[i]["ActionType"]));
                model.TypeA             = (LinkageType)Enum.ToObject(typeof(LinkageType), Convert.ToInt16(dt.Rows[i]["TypeA"]));
                model.LoopNoA           = dt.Rows[i]["LoopNoA"].ToString();
                model.DeviceTypeCodeA   = Convert.ToInt16(dt.Rows[i]["DeviceTypeCodeA"]);
                model.BuildingNoA       = new Nullable <Int16>(Convert.ToInt16(dt.Rows[i]["BuildingNoA"]));
                model.ZoneNoA           = new Nullable <Int16>(Convert.ToInt16(dt.Rows[i]["ZoneNoA"]));
                model.LayerNoA          = new Nullable <Int16>(Convert.ToInt16(dt.Rows[i]["LayerNoA"]));
                model.DeviceTypeCodeA   = Convert.ToInt16(dt.Rows[i]["DeviceTypeCodeA"]);
                model.TypeB             = (LinkageType)Enum.ToObject(typeof(LinkageType), Convert.ToInt16(dt.Rows[i]["TypeB"]));
                model.LoopNoB           = dt.Rows[i]["LoopNoB"].ToString();
                model.DeviceCodeB       = dt.Rows[i]["DeviceCodeB"].ToString();
                model.BuildingNoB       = new Nullable <Int16>(Convert.ToInt16(dt.Rows[i]["BuildingNoB"]));
                model.ZoneNoB           = new Nullable <Int16>(Convert.ToInt16(dt.Rows[i]["ZoneNoB"]));
                model.LayerNoB          = new Nullable <Int16>(Convert.ToInt16(dt.Rows[i]["LayerNoB"]));
                model.DeviceTypeCodeB   = Convert.ToInt16(dt.Rows[i]["DeviceTypeCodeB"]);
                model.TypeC             = (LinkageType)Enum.ToObject(typeof(LinkageType), Convert.ToInt16(dt.Rows[i]["TypeC"]));
                model.MachineNoC        = dt.Rows[i]["MachineNoC"].ToString();
                model.LoopNoC           = dt.Rows[i]["LoopNoC"].ToString();
                model.DeviceCodeC       = dt.Rows[i]["DeviceCodeC"].ToString();
                model.BuildingNoC       = new Nullable <Int16>(Convert.ToInt16(dt.Rows[i]["BuildingNoC"]));
                model.ZoneNoC           = new Nullable <Int16>(Convert.ToInt16(dt.Rows[i]["ZoneNoC"]));
                model.LayerNoC          = new Nullable <Int16>(Convert.ToInt16(dt.Rows[i]["LayerNoC"]));
                model.DeviceTypeCodeC   = Convert.ToInt16(dt.Rows[i]["DeviceTypeCodeC"]);
                model.Controller        = controller;
                model.ControllerID      = controller.ID;
                lstData.Add(model);
            }
            return(lstData);
        }
Beispiel #6
0
        public List <LinkageConfigMixed> GetMixedLinkageConfig()
        {
            List <LinkageConfigMixed> lstMixedConfig = new List <LinkageConfigMixed>();

            try
            {
                StringBuilder sbQuerySQL  = new StringBuilder("select 编号,动作常数,动作类型,分类A,楼号A,区号A,层号A,类型A,分类B,楼号B,区号B,层号B,类型B,分类C,楼号C,区号C,层号C,类型C from 混合组态;");
                DataTable     dt          = _databaseService.GetDataTableBySQL(sbQuerySQL);
                int           dtRowsCount = dt.Rows.Count;
                for (int i = 0; i < dtRowsCount; i++)
                {
                    LinkageConfigMixed linkageConfigMixed = new LinkageConfigMixed();
                    linkageConfigMixed.Code = dt.Rows[i]["编号"].ToString();
                    linkageConfigMixed.ActionCoefficient = Convert.ToInt32(dt.Rows[i]["动作常数"]);
                    linkageConfigMixed.ActionType        = ConvertLinkageActionType(dt.Rows[i]["动作类型"].ToString());

                    linkageConfigMixed.TypeA = ConvertLinkageType(dt.Rows[i]["分类A"].ToString());
                    if (linkageConfigMixed.TypeA == LinkageType.ZoneLayer)
                    {
                        linkageConfigMixed.BuildingNoA     = dt.Rows[i]["楼号A"].ToString().ToNullable <int>();
                        linkageConfigMixed.ZoneNoA         = dt.Rows[i]["区号A"].ToString().ToNullable <int>();
                        linkageConfigMixed.LayerNoA        = dt.Rows[i]["层号A"].ToString().ToNullable <int>();
                        linkageConfigMixed.DeviceTypeCodeA = ConvertDeviceTypeCodeToCurrentVersion(dt.Rows[i]["类型A"].ToString());
                    }
                    else if (linkageConfigMixed.TypeA == LinkageType.Address)
                    {
                        linkageConfigMixed.LoopNoA     = dt.Rows[i]["区号A"].ToString();
                        linkageConfigMixed.DeviceCodeA = dt.Rows[i]["层号A"].ToString();
                    }

                    linkageConfigMixed.TypeB = ConvertLinkageType(dt.Rows[i]["分类B"].ToString());
                    if (linkageConfigMixed.TypeB == LinkageType.ZoneLayer)
                    {
                        linkageConfigMixed.BuildingNoB     = dt.Rows[i]["楼号B"].ToString().ToNullable <int>();
                        linkageConfigMixed.ZoneNoB         = dt.Rows[i]["区号B"].ToString().ToNullable <int>();
                        linkageConfigMixed.LayerNoB        = dt.Rows[i]["层号B"].ToString().ToNullable <int>();
                        linkageConfigMixed.DeviceTypeCodeB = ConvertDeviceTypeCodeToCurrentVersion(dt.Rows[i]["类型B"].ToString());
                    }
                    else
                    {
                        linkageConfigMixed.LoopNoB     = dt.Rows[i]["区号B"].ToString();
                        linkageConfigMixed.DeviceCodeB = dt.Rows[i]["层号B"].ToString();
                    }

                    linkageConfigMixed.TypeC = ConvertLinkageType(dt.Rows[i]["分类C"].ToString());
                    if (linkageConfigMixed.TypeC == LinkageType.ZoneLayer)
                    {
                        linkageConfigMixed.BuildingNoC     = dt.Rows[i]["楼号C"].ToString().ToNullable <int>();
                        linkageConfigMixed.ZoneNoC         = dt.Rows[i]["区号C"].ToString().ToNullable <int>();
                        linkageConfigMixed.LayerNoC        = dt.Rows[i]["层号C"].ToString().ToNullable <int>();
                        linkageConfigMixed.DeviceTypeCodeC = ConvertDeviceTypeCodeToCurrentVersion(dt.Rows[i]["类型C"].ToString());
                    }
                    else
                    {
                        linkageConfigMixed.MachineNoC  = dt.Rows[i]["楼号C"].ToString();
                        linkageConfigMixed.LoopNoC     = dt.Rows[i]["区号C"].ToString();
                        linkageConfigMixed.DeviceCodeC = dt.Rows[i]["层号C"].ToString();
                    }
                    lstMixedConfig.Add(linkageConfigMixed);
                }
            }
            catch
            {
            }
            return(lstMixedConfig);
        }
Beispiel #7
0
        //3>更新混合组态: 器件类型A,器件类型B,器件类型C
        //的“点动”及“字锁”字样去掉,对于在101及129范围内的器件编码-64
        private bool UpdateMixedLinkageConfigInfo(LinkageConfigMixed mixedConfig)
        {
            bool result = false;

            try
            {
                if (mixedConfig.DeviceTypeNameA != null)
                {
                    if (mixedConfig.DeviceTypeNameA.Length > 0) //更新器件类型A
                    {
                        Int16 deviceTypeA = Convert.ToInt16(mixedConfig.DeviceTypeNameA.Substring(0, 3));
                        if (deviceTypeA >= 101 && deviceTypeA <= 129)
                        {
                            mixedConfig.DeviceTypeCodeA = Convert.ToInt16(deviceTypeA - 64);
                        }
                        else
                        {
                            mixedConfig.DeviceTypeCodeA = deviceTypeA;
                        }
                    }
                }
                else
                {
                    mixedConfig.DeviceTypeCodeA = 0;
                }
                if (mixedConfig.DeviceTypeNameB != null)
                {
                    if (mixedConfig.DeviceTypeNameB.Length > 0) //更新器件类型B
                    {
                        Int16 deviceTypeB = Convert.ToInt16(mixedConfig.DeviceTypeNameB.Substring(0, 3));
                        if (deviceTypeB >= 101 && deviceTypeB <= 129)
                        {
                            mixedConfig.DeviceTypeCodeB = Convert.ToInt16(deviceTypeB - 64);
                        }
                        else
                        {
                            mixedConfig.DeviceTypeCodeB = deviceTypeB;
                        }
                    }
                }
                else
                {
                    mixedConfig.DeviceTypeCodeB = 0;
                }
                if (mixedConfig.DeviceTypeNameC != null)
                {
                    if (mixedConfig.DeviceTypeNameC.Length > 0) //更新器件类型C
                    {
                        Int16 deviceTypeC = Convert.ToInt16(mixedConfig.DeviceTypeNameC.Substring(0, 3));
                        if (deviceTypeC >= 101 && deviceTypeC <= 129)
                        {
                            mixedConfig.DeviceTypeCodeC = Convert.ToInt16(deviceTypeC - 64);
                        }
                        else
                        {
                            mixedConfig.DeviceTypeCodeC = deviceTypeC;
                        }
                    }
                }
                else
                {
                    mixedConfig.DeviceTypeCodeC = 0;
                }
                result = true;
            }
            catch (Exception ex)
            {
                result = false;
            }

            return(result);
        }
Beispiel #8
0
 public int AddMixedLinkageConfigInfo(LinkageConfigMixed linkageConfigMixed)
 {
     throw new NotImplementedException();
 }
        /// <summary>
        /// 更新指定混合组态ID的数据
        /// </summary>
        /// <param name="id">待更新数据的ID</param>
        /// <param name="columnNames">列名</param>
        /// <param name="data">新数据</param>
        /// <returns></returns>
        public bool UpdateViaSpecifiedColumnName(int id, string[] columnNames, string[] data)
        {
            try
            {
                LinkageConfigMixed result = _controller.MixedConfig.Find(
                    delegate(LinkageConfigMixed x)
                {
                    return(x.ID == id);
                }
                    );
                for (int i = 0; i < columnNames.Length; i++)
                {
                    switch (columnNames[i])
                    {
                    //case "编号":
                    //    result.Code = data[i];
                    //    break;
                    case "动作常数":
                        result.ActionCoefficient = Convert.ToInt32(data[i]);
                        break;

                    case "动作类型":
                    {
                        LinkageActionType lActiontype = result.ActionType;
                        Enum.TryParse <LinkageActionType>(EnumUtility.GetEnumName(lActiontype.GetType(), data[i]), out lActiontype);
                        result.ActionType = lActiontype;
                    }
                    break;

                    case "A分类":
                    {
                        LinkageType linkageType = result.TypeA;
                        Enum.TryParse <LinkageType>(EnumUtility.GetEnumName(linkageType.GetType(), data[i]), out linkageType);
                        result.TypeA = linkageType;
                    }
                    break;

                    case "A类别":
                    {
                        switch (data[i])
                        {
                        case "本系统":
                            result.CategoryA = 0;
                            break;

                        case "它系统":
                            result.CategoryA = 1;
                            break;

                        case "全系统":
                            result.CategoryA = 2;
                            break;
                        }
                    }
                    break;

                    case "A楼号":
                        result.BuildingNoA = new Nullable <int>(Convert.ToInt32(data[i]));
                        break;

                    case "A区号":
                        result.ZoneNoA = new Nullable <int>(Convert.ToInt32(data[i]));
                        break;

                    case "A层号":
                        result.LayerNoA = new Nullable <int>(Convert.ToInt32(data[i]));
                        break;

                    case "A路号":
                        result.LoopNoA = data[i].ToString();
                        break;

                    case "A编号":
                        result.DeviceCodeA = data[i].ToString();
                        break;

                    case "A类型":
                        result.DeviceTypeCodeA = Convert.ToInt16(data[i]);
                        break;

                    case "B分类":
                    {
                        LinkageType linkageType = result.TypeB;
                        Enum.TryParse <LinkageType>(EnumUtility.GetEnumName(linkageType.GetType(), data[i]), out linkageType);
                        result.TypeB = linkageType;
                    }
                    break;

                    case "B类别":
                    {
                        switch (data[i])
                        {
                        case "本系统":
                            result.CategoryB = 0;
                            break;

                        case "它系统":
                            result.CategoryB = 1;
                            break;

                        case "全系统":
                            result.CategoryB = 2;
                            break;
                        }
                    }
                    break;

                    case "B楼号":
                        result.BuildingNoB = new Nullable <int>(Convert.ToInt32(data[i]));
                        break;

                    case "B区号":
                        result.ZoneNoB = new Nullable <int>(Convert.ToInt32(data[i]));
                        break;

                    case "B层号":
                        result.LayerNoB = new Nullable <int>(Convert.ToInt32(data[i]));
                        break;

                    case "B路号":
                        result.LoopNoB = data[i].ToString();
                        break;

                    case "B编号":
                        result.DeviceCodeB = data[i].ToString();
                        break;

                    case "B类型":
                        result.DeviceTypeCodeB = Convert.ToInt16(data[i]);
                        break;

                    case "C分类":
                    {
                        LinkageType linkageType = result.TypeC;
                        Enum.TryParse <LinkageType>(EnumUtility.GetEnumName(linkageType.GetType(), data[i]), out linkageType);
                        result.TypeC = linkageType;
                    }
                    break;

                    case "C楼号":
                        result.BuildingNoC = new Nullable <int>(Convert.ToInt32(data[i]));
                        break;

                    case "C区号":
                        result.ZoneNoC = new Nullable <int>(Convert.ToInt32(data[i]));
                        break;

                    case "C层号":
                        result.LayerNoC = new Nullable <int>(Convert.ToInt32(data[i]));
                        break;

                    case "C机号":
                        result.MachineNoC = data[i].ToString();
                        break;

                    case "C回路号":
                        result.LoopNoC = data[i].ToString();
                        break;

                    case "C编号":
                        result.DeviceCodeC = data[i].ToString();
                        break;

                    case "C类型":
                        result.DeviceTypeCodeC = Convert.ToInt16(data[i]);
                        break;
                    }
                }
            }
            catch (Exception ex)
            {
                return(false);
            }
            return(true);
        }
 public bool Update(Model.LinkageConfigMixed linkageConfigMixed)
 {
     try
     {
         LinkageConfigMixed result = _controller.MixedConfig.Find(
             delegate(LinkageConfigMixed x)
         {
             return(x.ID == linkageConfigMixed.ID);
         }
             );
         if (result != null)
         {
             result.Code              = linkageConfigMixed.Code;
             result.Controller        = linkageConfigMixed.Controller;
             result.ControllerID      = linkageConfigMixed.ControllerID;
             result.ActionCoefficient = linkageConfigMixed.ActionCoefficient;
             result.ActionType        = linkageConfigMixed.ActionType;
             //分类A
             result.TypeA = linkageConfigMixed.TypeA;
             //回路A
             //器件编号A [当分类为“地址”时,存储的"回路编号"]
             result.LoopNoA = linkageConfigMixed.LoopNoA;
             //器件编号A [当分类为“地址”时,存储的"器件编号"]
             result.DeviceCodeA = linkageConfigMixed.DeviceCodeA;
             result.CategoryA   = linkageConfigMixed.CategoryA;
             //楼号A
             result.BuildingNoA = linkageConfigMixed.BuildingNoA;
             //区号A
             result.ZoneNoA = linkageConfigMixed.ZoneNoA;
             //层号A
             result.LayerNoA = linkageConfigMixed.LayerNoA;
             //器件类型A
             result.DeviceTypeCodeA = linkageConfigMixed.DeviceTypeCodeA;
             result.TypeB           = linkageConfigMixed.TypeB;
             result.LoopNoB         = linkageConfigMixed.LoopNoB;
             result.DeviceCodeB     = linkageConfigMixed.DeviceCodeB;
             result.CategoryB       = linkageConfigMixed.CategoryB;
             result.BuildingNoB     = linkageConfigMixed.BuildingNoB;
             result.ZoneNoB         = linkageConfigMixed.ZoneNoB;
             result.LayerNoB        = linkageConfigMixed.LayerNoB;
             result.DeviceTypeCodeB = linkageConfigMixed.DeviceTypeCodeB;
             result.TypeC           = linkageConfigMixed.TypeC;
             result.MachineNoC      = linkageConfigMixed.MachineNoC;
             result.LoopNoC         = linkageConfigMixed.LoopNoC;
             result.DeviceCodeC     = linkageConfigMixed.DeviceCodeC;
             result.BuildingNoC     = linkageConfigMixed.BuildingNoC;
             result.ZoneNoC         = linkageConfigMixed.ZoneNoC;
             result.LayerNoC        = linkageConfigMixed.LayerNoC;
             result.DeviceTypeCodeC = linkageConfigMixed.DeviceTypeCodeC;
         }
         else
         {
             _controller.MixedConfig.Add(linkageConfigMixed);
             DataRecordAlreadySet = true;
             if (linkageConfigMixed.ID > ProjectManager.GetInstance.MaxIDForMixedLinkageConfig)
             {
                 ProjectManager.GetInstance.MaxIDForMixedLinkageConfig = linkageConfigMixed.ID;
             }
             else
             {
                 ProjectManager.GetInstance.MaxIDForMixedLinkageConfig++;
             }
         }
     }
     catch
     {
         return(false);
     }
     return(true);
 }