写程序遇到一个逻辑问题,欢迎大家来讨论。100分相送

Question

你这不是逻辑问题...建议你好好学一下OOP...Form只是呈现...逻辑处理要先设计好...检测数据要存储...有了存储的数据你想计算什么都可以...

Answer 1

TO:smaworm 任一不合格也不能这么办啊.像你那样计算,如果同时检测5个产品,两台仪器分别都认为全部不合格,一加岂不是10了?

Answer 2

TO:hli33 机器是同时检测,在一秒7产品的速度下,难以保证触发事件也是同时吧?

Answer 3

按你的需求，不要试图从时间延迟这点来判断是否是同一个产品。而是对a、b机器检测的产品分别独立的判断是否合格，最后进行一个汇总。这里问题的关键是4L说的“你的产品是否存在序列号并且可以让机器检测出来”。因为这是能够汇总的前提。

Answer 4

原来你的这两个检测仪器是绑定在一起的啊，我本来以为是分来的两个。
如果是分开的话，假设检测100个产品，两台分别检测50个
a检测出2个不合格
b检测出3个不合格
那么不合格的肯定要剔除掉啊，不用再重复检测了。
也就是a只要再检测47个
b只要检测48个就好了

Answer 5

1.被检测的产品必须包含两个检测的结果a和b,另有一个是否已被检测的标识flag
2.将被检测的产品放入一个ArrayList中
3.获取ArrayList中flag为true的数量,和所有a&&b的结果即可得出你要的数据

Answer 6

接14楼
两个ArrayList ar1,ar2
a机器检测的结果存ar1合格存1合格存0
ar1{1,1,1,0,0,0}
b机器检测的结果存ar2合格存1合格存0
ar2{1,1,1,0,1,1}数组的index对应你产品
a.b分别检测该产品的不用部位
如果ar1[0]*ar1[0]=1那么产品0合格
如果ar1[4]*ar1[4]=0那么产品4不合格

Answer 7

修正：
a机器检测的结果存ar1合格存1不合格存0 
ar1{1,1,1,0,0,0} 
b机器检测的结果存ar2合格存1不合格存0 
ar2{1,1,1,0,1,1} 

Answer 8

你真的都明白？你的需求和逻辑都不清楚怎么给你结果？如果同一产品两台仪器都报不合格，那么不合格数加一；如果只有一台仪器报不合格，那么不合格数也加一。注意：两台仪器有可能只有一台工作。 
---------------------------
不工作的算什么？不合格？例：产品P；
仪器A检测的项：A1,A2,A3；
仪器B检测的项：B1,B2,B3；你关心仪器A还是仪器B？错了，要关心的是P...这样P至少有七个属性：ID,A1,A2,A3,B1,B2,B3；1.用两个线程从A和B取检测数据，不要去管什么事件，只管把数据存起来...
2.用第三个线程读取数据，合不合格有多少合格只是统计分析的事罢了...

Answer 9

TO:CMIC能否说的再明白些,刚刚你说的我没能理解清楚,谢谢!

Answer 10

一个产品有两个检查项. a 和b 
每个检查项可能有三个状态之一 合格/不合格/未定义
一个产品检查列表可能是
产品  状态a 状态b
1     true   null
2     false  false
3     null   true....................
至于怎么查不合格的总数要看逻辑了.
一般的来说只要有一个状态为不合格,我们则一般可以认定此产品不合格
.不管用什么方式存储的上述状态列表,应该都很容易找到你要的答案了

Answer 11

产品    设备         状态
1      a          合格
1      b          不合格
2      b          合格 

Answer 12

想到另一个方法：用一个HashTable，型号作键（如果有的话，没有就当我没发过这些贴子），状态作值。剩下的不用我多说了吧。

Answer 13

两台仪器分别为两个对象，两个对象中分别一个属性列表，可以使用HashTable,即本仪器监视的index已经是否合格
还有需要一个属性，就是本仪器开始的时候，另外一个仪器所监视的index。
这样的话只要对比本仪器和另外一个仪器的相应index，已经是否合格就可以了，当然先开的仪器不是从第一个开始计算了，是从后开的那个仪器的记录的index开始计算。

Answer 14

即
Machine machine
{
//记录检测的index，以及相应的产品是否合格
HashTable ht;
//记录本机开始的时候，先开的机器在监测的第几个产品。为0的时候说明本仪器先开。
int index;
}
后面 后开的从1开始计算，先开的从index开始计算，同时计算产品是否合格。

Answer 15

//========================产品合格类==========================
class Product
{private bool bool passproduct=false;//该产品是否合格
public bool GetProduct{get{return this.product;}}
private bool passA=false;//a仪器检测是否合格
private bool passB=false;//b仪器检测是否合格
public Product(bool a,bool b)//构造函数
{
this.passA=a;
this.passB=b;
if(this.passA==true&&this.passB==true)
{
this.product=true;
}
else
{
this.product=false;
}
}
//===========================以下是主程序========================
class Main
{
private static int passCount=0;
private static int allCount=0;public static void Main()
{
bool pass=true;
while(pass)
{
Product p=new Product(仪器a检测报告,仪器b检测报告)
if(p.passproduct==true)
{
allCount+=1;
passCount+=1;
}
else
{
allCount+=1;
}
pass=Convert.ToBool(Console.ReadLine());//是否需要判断下一个产品
}
Console.WriteLine("一共检验了{0}件产品,其中合格的有{1}件",allCount.ToString(),passCount.ToString());
//
}

Answer 16

既然是同时,用二维数组怎么样?
{{0,0}
 {0,1}
 {1,0}
 {1,1}}
sum=0;sum++;

Answer 17

一个线程用两个Queue<Bool>()分别记录A、B设备的检测结果，一个线程统计结果，同时给Queue减肥。

Answer 18

这是我43楼的例程，主线程计数，子线程启动设备检测。
using System;
using System.Collections.Generic;
using System.Threading;namespace ConsoleApplication74
{
    class Instrument
    {
        public static int Count;
        private string name;
        private int number;        public Instrument(string name)
        {
            this.name = name;
            this.number = 0;
            this.results = new Queue<bool>();
        }        private Queue<bool> results;
        public Queue<bool> Results
        {
            get { return results; }
        }        public void Detect()
        {
            while (number++ < Instrument.Count)
            {
                Thread.Sleep(new Random().Next(500));
                bool result = (new Random().Next(2) == 0);
                Console.WriteLine("设备{0}检测到第{1}个产品{2}", name, number, result ? "合格" : "不合格");
                results.Enqueue(result);
            }
        }        public static int BadCounter(params Instrument[] instruments)
        {
            int number = 0;
            int badCount = 0;
            while (number++ < Instrument.Count)
            {
                bool result = true;
                foreach (Instrument i in instruments)
                {
                    while (i.results.Count == 0)
                    {
                        Thread.Sleep(100);
                    }
                }
                foreach (Instrument i in instruments)
                {
                    result &= i.results.Dequeue();
                }
                if (!result)
                    badCount++;
            }
            return badCount;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Instrument.Count = 10;
            Instrument a = new Instrument("A");
            Instrument b = new Instrument("B");
            new Thread(a.Detect).Start();
            new Thread(b.Detect).Start();
            int badCount = Instrument.BadCounter(a, b);
            Console.WriteLine("检测到不合格产品{0}个", badCount);
            Console.ReadKey();
        }
    }
}

Answer 19

using System;
using System.Collections.Generic;
using System.Threading;namespace ConsoleApplication74
{
    class Instrument
    {
        // 待检测产品的数量
        public static int Count;
        
        // 检测仪器的动态对象的名字
        private string name;        // 检测仪器的动态对象检测产品的个数
        private int number;        // 检测仪器的动态对象检测出的结果的缓存队列
        private Queue<bool> results;
        public Queue<bool> Results
        {
            get { return results; }
        }
        
        public Instrument(string name)
        {
            this.name = name;
            this.number = 0;
            this.results = new Queue<bool>();
        }        // 检测仪器的动态对象的检测方法
        // 用随机数模拟检测时的时延和检测结果
        public void Detect()
        {
            // 检测完所有产品后
            // 检测仪器的动态对象的检测方法才结束
            while (number++ < Instrument.Count)
            {
                // 模拟时延，造成两个检测仪器有时检测两个产品的情况
                Thread.Sleep(new Random().Next(500));                // 模拟结果，随机数是 0 就代表检测结果合格
                bool result = (new Random().Next(2) == 0);
                Console.WriteLine("设备{0}检测到第{1}个产品{2}", name, number, result ? "合格" : "不合格");
                
                // 结果加入缓存队列
                results.Enqueue(result);
            }
        }        // 此静态方法用于计数，在该类中定义只为归类好看，定义在别的类里也行
        public static int BadCounter(params Instrument[] instruments)
        {
            // 记录统计了多少个产品的结果
            int number = 0;
            
            // 记录不合格产品的数量
            int badCount = 0;            // 统计完所有产品的结果后才结束循环，返回结果
            while (number++ < Instrument.Count)
            {
                // 因为要统计不合格的 (false)
                // 所以先假设当前产品是合格的 (true)
                // 只要有发现任何一个检测结果不合格，该变量就会变为 false
                bool result = true;                // 检测当前产品所有检测是否都已有结果
                foreach (Instrument i in instruments)
                {
                    // 如果当前读取的缓存里没有结果，就等100毫秒，再读一下看看
                    while (i.results.Count == 0)
                    {
                        Thread.Sleep(100);
                    }
                }                // 把当前产品的所有检测结果从缓存里剔除
                // 并与 result 进行 & 计算
                // 所有结果都为 true ，该产品才能合格
                foreach (Instrument i in instruments)
                {
                    result &= i.results.Dequeue();
                }                // 如果不合格，计数
                if (!result)
                    badCount++;
            }
            
            // 返回不合格的产品数量
            return badCount;
        }
    }
    class Program
    {
        // 问题1：流水线长时间检测，用表保存全部结果可能会溢出
        // 问题2：流水线上的产品不一定有序列号，就是有，让检测仪器读取也会很麻烦
        // 方案 ：用 Queue 队列缓存各仪器的检测结果，计数程序随时计数并释放内存，控制缓存的大小
        //        同时让所有检测仪器按顺序检测，并保存结果，保证顺序就不需要序列号了。        static void Main(string[] args)
        {
            // 初始化待检测产品的数量,假设是10个
            // 此静态变量是检测方法和计数方法的结束条件
            Instrument.Count = 10;            // 实例化两个检测仪器
            Instrument a = new Instrument("A");
            Instrument b = new Instrument("B");
            
            // 启动仪器的检测程序,依次检测产品
            // 检测结果会保存进 results 里
            // results 是每个仪器对象自身的 Queue<bool> 队列
            new Thread(a.Detect).Start();
            new Thread(b.Detect).Start();            // 启动计数程序
            // 同一产品的各个检测结果在计数后就没有用了，所以一齐清理掉,释放内存
            // 这样长时间检测也没问题
            int badCount = Instrument.BadCounter(a, b);
            Console.WriteLine("检测到不合格产品{0}个", badCount);
            Console.ReadKey();
        }
    }
}加上注释，省得看着累眼