C#实现求CPK和最大值最小值：
求CPK：

CPK是衡量一个过程是否稳定的指标。它的计算公式是：

CPK = Min(USL-μ, μ-LSL)/(3*σ)

其中，USL为上限规格限，LSL为下限规格限，μ为平均值，σ为标准差。

C#代码实现：

using System;
using System.Collections.Generic;
using System.Linq;

class CpkCalculator {
    public double CalculateCpk(List<double> data, double usl, double lsl) {
        double average = data.Average();
        double standardDeviation = CalculateStandardDeviation(data, average);
        double cpk = Math.Min((usl - average) / (3 * standardDeviation), (average - lsl) / (3 * standardDeviation));
        return cpk;
    }

    private double CalculateStandardDeviation(List<double> data, double average) {
        double sumOfSquaresOfDifferences = data.Select(val => (val - average) * (val - average)).Sum();
        double variance = sumOfSquaresOfDifferences / (data.Count - 1);
        double standardDeviation = Math.Sqrt(variance);
        return standardDeviation;
    }
}

最大值和最小值：

C#提供了Max和Min方法可以很方便地求一个集合中的最大值和最小值。

C#代码实现：

using System;
using System.Collections.Generic;
using System.Linq;

class MaxMinCalculator {
    public double CalculateMax(List<double> data) {
        double max = data.Max();
        return max;
    }

    public double CalculateMin(List<double> data) {
        double min = data.Min();
        return min;
    }
}

使用设计模式设计一个类和接口描述：
根据上述需求，我们可以使用工厂模式来创建计算器对象，这样可以将具体的计算器对象的创建过程与客户端代码解耦合，从而使客户端代码更加简洁。

具体实现如下：

using System;
using System.Collections.Generic;
using System.Linq;

interface ICalculator {
    double Calculate(List<double> data);
}

class CpkCalculator : ICalculator {
    private double usl;
    private double lsl;

    public CpkCalculator(double usl, double lsl) {
        this.usl = usl;
        this.lsl = lsl;
    }

    public double Calculate(List<double> data) {
        double average = data.Average();
        double standardDeviation = CalculateStandardDeviation(data, average);
        double cpk = Math.Min((usl - average) / (3 * standardDeviation), (average - lsl) / (3 * standardDeviation));
        return cpk;
    }

    private double CalculateStandardDeviation(List<double> data, double average) {
        double sumOfSquaresOfDifferences = data.Select(val => (val - average) * (val - average)).Sum();
        double variance = sumOfSquaresOfDifferences / (data.Count - 1);
        double standardDeviation = Math.Sqrt(variance);
        return standardDeviation;
    }
}

class MaxCalculator : ICalculator {
    public double Calculate(List<double> data) {
        double max = data.Max();
        return max;
    }
}

class MinCalculator : ICalculator {
public double Calculate(List<double> data) {
double min = data.Min();
return min;
}
}

class CalculatorFactory {
public static ICalculator GetCalculator(string calculatorType, double usl = 0, double lsl = 0) {
switch (calculatorType) {
case "cpk":
return new CpkCalculator(usl, lsl);
case "max":
return new MaxCalculator();
case "min":
return new MinCalculator();
default:
throw new ArgumentException("Invalid calculator type");
}
}
}

// 客户端代码
List<double> data = new List<double> { 1.2, 2.4, 3.6, 4.8 };
double usl = 5.0;
double lsl = 0.0;

ICalculator cpkCalculator = CalculatorFactory.GetCalculator("cpk", usl, lsl);
double cpk = cpkCalculator.Calculate(data);
Console.WriteLine("CPK: " + cpk);

ICalculator maxCalculator = CalculatorFactory.GetCalculator("max");
double max = maxCalculator.Calculate(data);
Console.WriteLine("Max: " + max);

ICalculator minCalculator = CalculatorFactory.GetCalculator("min");
double min = minCalculator.Calculate(data);
Console.WriteLine("Min: " + min);

这里我们定义了一个ICalculator接口，它包含一个Calculate方法用于计算。然后我们定义了三个具体的计算器类，分别用于计算CPK、最大值和最小值。这些具体的计算器类实现了ICalculator接口的Calculate方法。

我们还定义了一个CalculatorFactory工厂类，它根据客户端代码传入的类型参数，返回相应的具体计算器对象。在客户端代码中，我们使用工厂类创建不同类型的计算器对象，并调用它们的Calculate方法进行计算。这样，客户端代码就不需要关心具体的计算器对象的创建过程，从而达到了解耦合的目的。