【C#】【EXCEL】Bumblebee/Classes/ExRange.cs

最新推荐文章于 2024-08-25 22:20:29 发布
最新推荐文章于 2024-08-25 22:20:29 发布
阅读量572 收藏 14
点赞数 17
文章标签： c# excel 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hmywillstronger/article/details/141533562
版权

Flow diagram

为了创建一个全面但不过于复杂的流程图，我们将重点关注 ExRange 类的主要功能和方法。以下是一个中英双语的流程图，展示了 ExRange 类的主要结构和操作流程：
默认构造函数
Default Constructor
COM 对象构造函数
COM Object Constructor
复制构造函数
Copy Constructor
属性操作
Property Operations
数据操作
Data Operations
格式化操作
Formatting Operations
条件格式化
Conditional Formatting
图表操作
Chart Operations
开始 / Start
创建 ExRange 实例
Create ExRange Instance
选择构造方法
Choose Constructor
创建空 ExRange
Create Empty ExRange
从 Excel Range 创建
Create from Excel Range
复制现有 ExRange
Copy Existing ExRange
选择操作类型
Choose Operation Type
获取/设置属性
Get/Set Properties
读取/写入数据
Read/Write Data
设置单元格格式
Set Cell Formatting
添加条件格式
Add Conditional Formatting
添加迷你图
Add Sparklines
字体属性
Font Properties
边框属性
Border Properties
单元格尺寸
Cell Dimensions
读取数据
Read Data
清除内容
Clear Content
设置字体
Set Font
设置边框
Set Border
合并单元格
Merge Cells
添加值条件
Add Value Condition
添加平均值条件
Add Average Condition
添加数据条
Add Data Bar
添加折线图
Add Line Sparkline
添加柱状图
Add Column Sparkline
操作完成
Operation Completed
结束 / End

这个流程图展示了 ExRange 类的主要功能和操作流程：

  1. 创建 ExRange 实例（对应构造函数）
  2. 选择操作类型（对应类中的不同方法组）
  3. 执行具体操作（对应具体的方法）
  4. 完成操作

流程图中的每个节点都有中英文说明，对应了代码中的相关部分。例如：

  • “创建 ExRange 实例” 对应了类的构造函数
  • “属性操作” 对应了类中的各种属性，如 FontFamily, FontSize 等
  • “数据操作” 对应了 ReadData() 和 ClearContent() 等方法
  • “格式化操作” 对应了 SetFont(), SetBorder() 等方法
  • “条件格式化” 对应了 AddConditionalValue(), AddConditionalAverage() 等方法
  • “图表操作” 对应了 AddSparkLine() 和 AddSparkColumn() 方法

Description

  1. ReadData() 方法
public GH_Structure<GH_String> ReadData()
{
    // 创建一个新的 GH_Structure 对象来存储单元格数据
    GH_Structure<GH_String> data = new GH_Structure<GH_String>();

    // 获取当前范围的边界信息（起始行列和结束行列）
    int[] L = GetRangeArray();

    // 从 Excel COM 对象中获取整个范围的值数组
    System.Array values = (System.Array)this.ComObj.Value2;

    // 如果值数组不为空，则开始处理数据
    if (values != null)
    {
        // 遍历行（注意：Excel 数组索引从 1 开始）
        for (int i = 1; i < (L[3] - L[1] + 2); i++)
        {
            // 为每一行创建一个新的路径
            GH_Path path = new GH_Path(i);
            // 遍历列
            for (int j = 1; j < (L[2] - L[0] + 2); j++)
            {
                // 初始化单元格值为空字符串
                string val = string.Empty;
                // 如果单元格不为空，则获取其字符串表示
                if (values.GetValue(i, j) != null) val = values.GetValue(i, j).ToString();
                // 将单元格值添加到数据结构中
                data.Append(new GH_String(val), path);
            }
        }
    }

    // 返回包含所有单元格值的数据结构
    return data;
}
  1. SetFont() 方法
public void SetFont(string name, double size, Sd.Color color, Justification justification, bool bold, bool italic)
{
    // 获取范围的字体对象
    XL.Font font = this.ComObj.Font;

    // 设置字体名称
    font.Name = name;
    // 设置字体大小
    font.Size = size;
    // 设置字体颜色
    font.Color = color;
    // 设置是否加粗
    font.Bold = bold;
    // 设置是否斜体
    font.Italic = italic;

    // 设置水平对齐方式（使用自定义的 Justification 枚举转换方法）
    this.ComObj.HorizontalAlignment = justification.ToExcelHalign();
    // 设置垂直对齐方式（使用自定义的 Justification 枚举转换方法）
    this.ComObj.VerticalAlignment = justification.ToExcelValign();
}
  1. AddConditionalValue() 方法
public void AddConditionalValue(ValueCondition condition, double value, Sd.Color color)
{
    // 用于标记条件是否有效
    bool valid = true;

    // 根据不同的条件类型添加相应的条件格式
    switch (condition)
    {
        case ValueCondition.Greater:
            // 添加"大于"条件格式
            this.ComObj.FormatConditions.Add(XL.XlFormatConditionType.xlCellValue, XL.XlFormatConditionOperator.xlGreater, Formula1: value);
            break;
        case ValueCondition.GreaterEqual:
            // 添加"大于等于"条件格式
            this.ComObj.FormatConditions.Add(XL.XlFormatConditionType.xlCellValue, XL.XlFormatConditionOperator.xlGreaterEqual, Formula1: value);
            break;
        // ... 其他条件类型的处理（省略）
        default:
            // 如果条件类型无效，将 valid 标记为 false
            valid = false;
            break;
    }

    // 如果条件有效，设置条件格式的背景颜色
    if (valid) this.ComObj.FormatConditions[this.ComObj.FormatConditions.Count].Interior.Color = color;
}
  1. AddSparkLine() 方法
public void AddSparkLine(ExRange placement, Sd.Color color, double weight)
{
    // 在指定位置添加迷你图
    // this.ToString() 返回当前 ExRange 对象的地址字符串，用作数据源范围
    XL.SparklineGroup spark = placement.ComObj.SparklineGroups.Add(XL.XlSparkType.xlSparkLine, this.ToString());
    
    // 设置迷你图的颜色
    spark.SeriesColor.Color = color;
    
    // 设置迷你图线条的粗细
    spark.LineWeight = weight;
}

这些详细的中文注释解释了每个方法的功能、参数的作用以及实现的细节。它们有助于理解代码的逻辑和 Excel COM 对象的使用方式。这种详细的注释对于学习和维护代码都非常有帮助，特别是对于那些不熟悉 Excel 自动化或 COM 编程的开发者来说。

ExRange 类中的其他重要方法,并解释它们的功能。

  1. ReadFillColors() 方法
public GH_Structure<GH_ObjectWrapper> ReadFillColors()
{
    // 创建一个新的 GH_Structure 来存储结果
    GH_Structure<GH_ObjectWrapper> ranges = new GH_Structure<GH_ObjectWrapper>();

    // 获取范围的起始和结束列行
    int Ax = this.Start.Column;
    int Ay = this.Start.Row;
    int Bx = this.Extent.Column;
    int By = this.Extent.Row;

    int k = 0;
    // 遍历范围内的每一列
    for (int i = Ax; i < Bx+1; i++)
    {
        // 为每一列创建一个新的路径
        GH_Path path = new GH_Path(k);
        // 遍历该列中的每一行
        for (int j = Ay; j < By+1; j++)
        {
            // 创建单元格地址
            string address = new ExCell(i, j).Address;
            // 为每个单元格创建一个新的 ExRange 对象
            ExRange rng = new ExRange(this.ComObj.Worksheet.Range[address,address]);
            // 将 ExRange 对象添加到结构中
            ranges.Append(new GH_ObjectWrapper(rng), path);
        }
        k++;
    }

    // 返回包含所有单元格 ExRange 对象的结构
    return ranges;
}
  1. GetMinPixel() 和 GetMaxPixel() 方法
public Rg.Point3d GetMinPixel()
{
    // 返回范围左上角的像素坐标
    // ComObj.Left 和 ComObj.Top 分别表示左边距和上边距
    return new Rg.Point3d(this.ComObj.Left, this.ComObj.Top, 0);
}

public Rg.Point3d GetMaxPixel()
{
    // 获取范围的左边距和上边距
    double X = this.ComObj.Left;
    double Y = this.ComObj.Top;
    // 获取范围的宽度和高度
    double W = this.ComObj.Width;
    double H = this.ComObj.Height;
    // 返回范围右下角的像素坐标
    return new Rg.Point3d(X + W, Y + H, 0);
}
  1. ClearContent() 和 ClearFormat() 方法
public void ClearContent()
{
    // 清除范围内的所有内容，但保留格式
    this.ComObj.ClearContents();
}

public void ClearFormat()
{
    // 清除范围内的所有格式，但保留内容
    this.ComObj.ClearFormats();
}
  1. MergeCells() 和 UnMergeCells() 方法
public void MergeCells()
{
    // 合并选定范围内的所有单元格
    this.ComObj.MergeCells = true;
}

public void UnMergeCells()
{
    // 取消合并选定范围内的单元格
    this.ComObj.UnMerge();
}
  1. SetBorder() 方法
public void SetBorder(Sd.Color color, BorderWeight weight, LineType type, HorizontalBorder horizontal, VerticalBorder vertical)
{
    // 获取范围的边框对象
    XL.Borders borders = this.ComObj.Borders;
    XL.Border left, right, top, bottom, betweenHorizontal, betweenVertical;

    // 处理水平边框
    switch (horizontal)
    {
        case HorizontalBorder.All:
            // 设置底部边框
            bottom = borders[XL.XlBordersIndex.xlEdgeBottom];
            bottom.Weight = weight.ToExcel();
            bottom.Color = color;
            bottom.LineStyle = type.ToExcel();

            // 设置水平内部边框
            betweenHorizontal = borders[XL.XlBordersIndex.xlInsideHorizontal];
            betweenHorizontal.Weight = weight.ToExcel();
            betweenHorizontal.Color = color;
            betweenHorizontal.LineStyle = type.ToExcel();

            // 设置顶部边框
            top = borders[XL.XlBordersIndex.xlEdgeTop];
            top.Weight = weight.ToExcel();
            top.Color = color;
            top.LineStyle = type.ToExcel();
            break;
        // ... (其他情况的处理)
    }

    // 处理垂直边框
    switch (vertical)
    {
        case VerticalBorder.All:
            // 设置左侧边框
            left = borders[XL.XlBordersIndex.xlEdgeLeft];
            left.Weight = weight.ToExcel();
            left.Color = color;
            left.LineStyle = type.ToExcel();

            // 设置垂直内部边框
            betweenVertical = borders[XL.XlBordersIndex.xlInsideVertical];
            betweenVertical.Weight = weight.ToExcel();
            betweenVertical.Color = color;
            betweenVertical.LineStyle = type.ToExcel();

            // 设置右侧边框
            right = borders[XL.XlBordersIndex.xlEdgeRight];
            right.Weight = weight.ToExcel();
            right.Color = color;
            right.LineStyle = type.ToExcel();
            break;
        // ... (其他情况的处理)
    }
}
  1. AddSparkColumn() 方法
public void AddSparkColumn(ExRange placement, Sd.Color color)
{
    // 在指定位置添加柱状迷你图
    // this.ToString() 返回当前范围的地址，作为迷你图的数据源
    XL.SparklineGroup spark = placement.ComObj.SparklineGroups.Add(XL.XlSparkType.xlSparkLine, this.ToString());
    // 设置迷你图类型为柱状图
    spark.Type = XL.XlSparkType.xlSparkColumn;
    // 设置迷你图的颜色
    spark.SeriesColor.Color = color;
}
  1. AddConditionalScale() 方法
public void AddConditionalScale(Sd.Color first, Sd.Color second, Sd.Color third, double mid = 0.5)
{
    // 确保 mid 值在 0 到 1 之间
    mid = Math.Min(mid, 1.0);
    mid = Math.Max(mid, 0.0);
    // 添加一个三色刻度的条件格式
    XL.ColorScale scale = this.ComObj.FormatConditions.AddColorScale(3);

    // 设置最低值的颜色
    scale.ColorScaleCriteria[1].Type = XL.XlConditionValueTypes.xlConditionValueLowestValue;
    scale.ColorScaleCriteria[1].FormatColor.Color = first;

    // 设置中间值的颜色和位置
    scale.ColorScaleCriteria[2].Type = XL.XlConditionValueTypes.xlConditionValuePercentile;
    scale.ColorScaleCriteria[2].Value = (int)(mid*100.0);
    scale.ColorScaleCriteria[2].FormatColor.Color = second;

    // 设置最高值的颜色
    scale.ColorScaleCriteria[3].Type = XL.XlConditionValueTypes.xlConditionValueHighestValue;
    scale.ColorScaleCriteria[3].FormatColor.Color = third;
}

这些详细的注释解释了每个方法的功能、参数的作用以及实现的细节。它们有助于理解代码的逻辑和 Excel COM 对象的使用方式。这种详细的注释对于学习和维护代码都非常有帮助，特别是对于那些不熟悉 Excel 自动化或 COM 编程的开发者来说。

Code

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using Sd = System.Drawing;

using Rg = Rhino.Geometry;

using XL = Microsoft.Office.Interop.Excel;
using Grasshopper.Kernel.Data;
using Grasshopper.Kernel.Types;

namespace Bumblebee
{
    public class ExRange
    {
        #region members

        protected ExCell start = new ExCell();
        protected ExCell extent = new ExCell();

        public XL.Range ComObj = null;

        #endregion

        #region constructors

        public ExRange()
        {
        }

        public ExRange(XL.Range comObj)
        {
            this.ComObj = comObj;
            GetFirstCell();
            GetLastCell();
        }

        public ExRange(ExRange range)
        {
            this.ComObj = range.ComObj;
            this.start = range.Start;
            this.extent = range.Extent;
        }

        #endregion

        #region properties

        public virtual ExCell Start
        {
            get { return new ExCell(start); }
            set { start = new ExCell(value); }
        }

        public virtual ExCell Extent
        {
            get { return new ExCell(extent); }
            set { extent = new ExCell(value); }
        }

        public virtual ExWorksheet Worksheet
        {
            get { return new ExWorksheet(this.ComObj.Worksheet); }
        }

        public virtual ExWorkbook Workbook
        {
            get { return new ExWorkbook(this.Worksheet.Workbook); }
        }

        public virtual ExApp ParentApp
        {
            get { return new ExApp(this.ComObj.Application); }
        }

        public virtual bool IsSingle
        {
            get { return ((start.Column == extent.Column) & (start.Row == extent.Row)); }
        }

        public virtual string FontFamily
        {
            get { return this.ComObj.Font.Name; }
            set { this.ComObj.Font.Name = value; }
        }

        public virtual double FontSize
        {
            get { return this.ComObj.Font.Size; }
            set { this.ComObj.Font.Size = value; }
        }

        public virtual Sd.Color FontColor
        {
            get { return Sd.ColorTranslator.FromOle((int)this.ComObj.Font.Color); }
            set { this.ComObj.Font.Color = value; }
        }

        public virtual Justification FontJustification
        {
            set{
                this.ComObj.HorizontalAlignment = value.ToExcelHalign();
                this.ComObj.VerticalAlignment = value.ToExcelValign();
            }
            get
            {
                int align = 0;
                switch (this.ComObj.VerticalAlignment)
                {
                    case XL.XlVAlign.xlVAlignCenter:
                        align = 3;
                        break;
                    case XL.XlVAlign.xlVAlignTop:
                        align = 6;
                        break;
                }

                switch (this.ComObj.VerticalAlignment)
                {
                    case XL.XlHAlign.xlHAlignLeft:
                    case XL.XlHAlign.xlHAlignGeneral:
                        break;
                    case XL.XlHAlign.xlHAlignRight:
                        align += 2;
                        break;
                    default:
                        align += 1;
                        break;
                }
                return (Justification)align;
            }
        }

        public bool Bold
        {
            get { return this.ComObj.Font.Bold; }
            set { this.ComObj.Font.Bold = value; }
        }

        public bool Italic
        {
            get { return this.ComObj.Font.Italic; }
            set { this.ComObj.Font.Italic = value; }
        }

        public virtual BorderWeight Weight
        {
            get { return ((XL.XlBorderWeight)this.ComObj.Borders.Weight).ToBB(); }
        }

        public virtual LineType LineType
        {
            get { return ((XL.XlLineStyle)this.ComObj.Borders.LineStyle).ToBB(); }
        }

        public virtual Sd.Color BorderColor
        {
            get { return Sd.ColorTranslator.FromOle((int)this.ComObj.Borders.Color); }
        }

        public virtual Sd.Color Background
        {
            get { return Sd.ColorTranslator.FromOle((int)this.ComObj.Interior.Color); }
            set { this.ComObj.Interior.Color = value; }
        }

        public virtual int Width
        {
            get { return this.ComObj.Columns.ColumnWidth; }
            set { this.ComObj.Columns.ColumnWidth = value; }
        }

        public virtual int Height
        {
            get { return this.ComObj.Rows.RowHeight; }
            set { this.ComObj.Rows.RowHeight = value; }
        }

        #endregion

        #region methods

        #region data

        public GH_Structure<GH_String> ReadData()
        {
            GH_Structure<GH_String> data = new GH_Structure<GH_String>();

            int[] L = GetRangeArray();

            System.Array values = (System.Array)this.ComObj.Value2;

            if (values != null)
            {
                for (int i = 1; i < (L[3] - L[1] + 2); i++)
                {
                    GH_Path path = new GH_Path(i);
                    for (int j = 1; j < (L[2] - L[0] + 2); j++)
                    {
                        string val = string.Empty;
                        if (values.GetValue(i, j) != null) val = values.GetValue(i, j).ToString();
                        data.Append(new GH_String(val), path);
                    }
                }
            }

            return data;
        }

        #endregion

        #region Graphics

        public GH_Structure<GH_ObjectWrapper> ReadFillColors()
        {
            GH_Structure<GH_ObjectWrapper> ranges = new GH_Structure<GH_ObjectWrapper>();

            int Ax = this.Start.Column;
            int Ay = this.Start.Row;
            int Bx = this.Extent.Column;
            int By = this.Extent.Row;

            int k = 0;
            for (int i = Ax; i < Bx+1; i++)
                {
                    GH_Path path = new GH_Path(k);
                    for (int j = Ay; j < By+1; j++)
                    {
                    string address = new ExCell(i, j).Address;
                    ExRange rng = new ExRange(this.ComObj.Worksheet.Range[address,address]);
                    ranges.Append(new GH_ObjectWrapper(rng), path);
                    }
                k++;
                }

            return ranges;
        }

        #endregion

        #region Geometry

        protected int[] GetRangeArray()
        {
            return new int[] { this.Start.Column, this.Start.Row, this.Extent.Column, this.Extent.Row };
        }

        public Rg.Point3d GetMinPixel()
        {
            return new Rg.Point3d(this.ComObj.Left, this.ComObj.Top, 0);
        }

        public Rg.Point3d GetMaxPixel()
        {
            double X = this.ComObj.Left;
            double Y = this.ComObj.Top;

            double W = this.ComObj.Width;
            double H = this.ComObj.Height;

            return new Rg.Point3d(X + W, Y + H, 0);
        }

        #endregion

        #region Extract

        protected void GetFirstCell()
        {
            start= new ExCell(this.ComObj.Column, this.ComObj.Row, false, false);
        }

        protected ExRange GetFirstRange()
        {
            ExWorksheet sheet = new ExWorksheet(this.ComObj.Worksheet);
            return new ExRange(sheet.GetRange(start,start));
        }

        protected void GetLastCell()
        {
            extent= new ExCell(this.ComObj.Columns[this.ComObj.Columns.Count].Column, this.ComObj.Rows[this.ComObj.Rows.Count].Row, false, false);
        }

        public void ClearContent()
        {
            this.ComObj.ClearContents();
        }

        public void MergeCells()
        {
            this.ComObj.MergeCells = true;
        }

        public void UnMergeCells()
        {
            this.ComObj.UnMerge();
        }

        #endregion

        #region graphics

        public void ClearFormat()
        {
            this.ComObj.ClearFormats();
        }

        public void SetFont(string name, double size, Sd.Color color, Justification justification, bool bold, bool italic)
        {
            XL.Font font = this.ComObj.Font;

            font.Name = name;
            font.Size = size;
            font.Color = color;
            font.Bold = bold;
            font.Italic = italic;

            this.ComObj.HorizontalAlignment = justification.ToExcelHalign();
            this.ComObj.VerticalAlignment = justification.ToExcelValign();
        }

        public void SetBorder(Sd.Color color, BorderWeight weight, LineType type, HorizontalBorder horizontal, VerticalBorder vertical)
        {
            XL.Borders borders = this.ComObj.Borders;
            XL.Border left, right, top, bottom, betweenHorizontal, betweenVertical;

            switch (horizontal)
            {
                case HorizontalBorder.All:
                    bottom = borders[XL.XlBordersIndex.xlEdgeBottom];
                    bottom.Weight = weight.ToExcel();
                    bottom.Color = color;
                    bottom.LineStyle = type.ToExcel();

                    betweenHorizontal = borders[XL.XlBordersIndex.xlInsideHorizontal];
                    betweenHorizontal.Weight = weight.ToExcel();
                    betweenHorizontal.Color = color;
                    betweenHorizontal.LineStyle = type.ToExcel();

                    top = borders[XL.XlBordersIndex.xlEdgeTop];
                    top.Weight = weight.ToExcel();
                    top.Color = color;
                    top.LineStyle = type.ToExcel();
                    break;
                case HorizontalBorder.Between:
                    betweenHorizontal = borders[XL.XlBordersIndex.xlInsideHorizontal];
                    betweenHorizontal.Weight = weight.ToExcel();
                    betweenHorizontal.Color = color;
                    betweenHorizontal.LineStyle = type.ToExcel();
                    break;
                case HorizontalBorder.Both:
                    bottom = borders[XL.XlBordersIndex.xlEdgeBottom];
                    bottom.Weight = weight.ToExcel();
                    bottom.Color = color;
                    bottom.LineStyle = type.ToExcel();

                    top = borders[XL.XlBordersIndex.xlEdgeTop];
                    top.Weight = weight.ToExcel();
                    top.Color = color;
                    top.LineStyle = type.ToExcel();
                    break;
                case HorizontalBorder.Bottom:
                    bottom = borders[XL.XlBordersIndex.xlEdgeBottom];
                    bottom.Weight = weight.ToExcel();
                    bottom.Color = color;
                    bottom.LineStyle = type.ToExcel();
                    break;
                case HorizontalBorder.Top:
                    top = borders[XL.XlBordersIndex.xlEdgeTop];
                    top.Weight = weight.ToExcel();
                    top.Color = color;
                    top.LineStyle = type.ToExcel();
                    break;
            }

            switch (vertical)
            {
                case VerticalBorder.All:
                    left = borders[XL.XlBordersIndex.xlEdgeLeft];
                    left.Weight = weight.ToExcel();
                    left.Color = color;
                    left.LineStyle = type.ToExcel();

                    betweenVertical = borders[XL.XlBordersIndex.xlInsideVertical];
                    betweenVertical.Weight = weight.ToExcel();
                    betweenVertical.Color = color;
                    betweenVertical.LineStyle = type.ToExcel();

                    right = borders[XL.XlBordersIndex.xlEdgeRight];
                    right.Weight = weight.ToExcel();
                    right.Color = color;
                    right.LineStyle = type.ToExcel();
                    break;
                case VerticalBorder.Between:
                    betweenVertical = borders[XL.XlBordersIndex.xlInsideVertical];
                    betweenVertical.Weight = weight.ToExcel();
                    betweenVertical.Color = color;
                    betweenVertical.LineStyle = type.ToExcel();
                    break;
                case VerticalBorder.Both:
                    left = borders[XL.XlBordersIndex.xlEdgeLeft];
                    left.Weight = weight.ToExcel();
                    left.Color = color;
                    left.LineStyle = type.ToExcel();

                    right = borders[XL.XlBordersIndex.xlEdgeRight];
                    right.Weight = weight.ToExcel();
                    right.Color = color;
                    right.LineStyle = type.ToExcel();
                    break;
                case VerticalBorder.Left:
                    left = borders[XL.XlBordersIndex.xlEdgeLeft];
                    left.Weight = weight.ToExcel();
                    left.Color = color;
                    left.LineStyle = type.ToExcel();
                    break;
                case VerticalBorder.Right:
                    right = borders[XL.XlBordersIndex.xlEdgeRight];
                    right.Weight = weight.ToExcel();
                    right.Color = color;
                    right.LineStyle = type.ToExcel();
                    break;
            }

        }

        #endregion

        #region sparklines

        public void AddSparkLine(ExRange placement, Sd.Color color, double weight)
        {
            XL.SparklineGroup spark = placement.ComObj.SparklineGroups.Add(XL.XlSparkType.xlSparkLine, this.ToString());
            spark.SeriesColor.Color= color;
            spark.LineWeight = weight;
        }

        public void AddSparkColumn(ExRange placement, Sd.Color color)
        {
            XL.SparklineGroup spark = placement.ComObj.SparklineGroups.Add(XL.XlSparkType.xlSparkLine, this.ToString());
            spark.Type = XL.XlSparkType.xlSparkColumn;
            spark.SeriesColor.Color = color;
        }

        #endregion

        #region conditional

        public void ClearConditions()
        {
            this.ComObj.FormatConditions.Delete();
        }

        public void AddConditionalValue(ValueCondition condition, double value, Sd.Color color)
        {
            bool valid = true;

            switch (condition)
            {
                case ValueCondition.Greater:
                    this.ComObj.FormatConditions.Add(XL.XlFormatConditionType.xlCellValue, XL.XlFormatConditionOperator.xlGreater, Formula1: value);
                    break;
                case ValueCondition.GreaterEqual:
                    this.ComObj.FormatConditions.Add(XL.XlFormatConditionType.xlCellValue, XL.XlFormatConditionOperator.xlGreaterEqual, Formula1: value);
                    break;
                case ValueCondition.Less:
                    this.ComObj.FormatConditions.Add(XL.XlFormatConditionType.xlCellValue, XL.XlFormatConditionOperator.xlLess, Formula1: value);
                    break;
                case ValueCondition.LessEqual:
                    this.ComObj.FormatConditions.Add(XL.XlFormatConditionType.xlCellValue, XL.XlFormatConditionOperator.xlLessEqual, Formula1: value);
                    break;
                case ValueCondition.Equal:
                    this.ComObj.FormatConditions.Add(XL.XlFormatConditionType.xlCellValue, XL.XlFormatConditionOperator.xlEqual, Formula1: value);
                    break;
                case ValueCondition.NotEqual:
                    this.ComObj.FormatConditions.Add(XL.XlFormatConditionType.xlCellValue, XL.XlFormatConditionOperator.xlNotEqual, Formula1: value);
                    break;
                default:
                    valid = false;
                    break;
            }
            if (valid) this.ComObj.FormatConditions[this.ComObj.FormatConditions.Count].Interior.Color = color;

        }

        public void AddConditionalAverage(AverageCondition condition, Sd.Color color)
        {
            bool valid = true;

            switch (condition)
            {
                case AverageCondition.AboveAverage:
                    this.ComObj.FormatConditions.Add(XL.XlFormatConditionType.xlAboveAverageCondition, XL.XlAboveBelow.xlAboveAverage);
                    break;
                case AverageCondition.AboveDeviation:
                    this.ComObj.FormatConditions.Add(XL.XlFormatConditionType.xlAboveAverageCondition, XL.XlAboveBelow.xlAboveStdDev);
                    break;
                case AverageCondition.AboveEqualAverage:
                    this.ComObj.FormatConditions.Add(XL.XlFormatConditionType.xlAboveAverageCondition, XL.XlAboveBelow.xlEqualAboveAverage);
                    break;
                case AverageCondition.BelowAverage:
                    this.ComObj.FormatConditions.Add(XL.XlFormatConditionType.xlAboveAverageCondition, XL.XlAboveBelow.xlBelowAverage);
                    break;
                case AverageCondition.BelowDeviation:
                    this.ComObj.FormatConditions.Add(XL.XlFormatConditionType.xlAboveAverageCondition, XL.XlAboveBelow.xlBelowStdDev);
                    break;
                case AverageCondition.BelowEqualAverage:
                    this.ComObj.FormatConditions.Add(XL.XlFormatConditionType.xlAboveAverageCondition, XL.XlAboveBelow.xlEqualBelowAverage);
                    break;
                default:
                    valid = false;
                    break;
            }
            if (valid) this.ComObj.FormatConditions[this.ComObj.FormatConditions.Count].Interior.Color = color;

        }

        public void AddConditionalBetween(double low, double high, Sd.Color color, bool flip=false)
        {
            if (flip)
            {
                this.ComObj.FormatConditions.Add(XL.XlFormatConditionType.xlCellValue, XL.XlFormatConditionOperator.xlNotBetween, Formula1: low,Formula2:high);
            }
            else
            {
                this.ComObj.FormatConditions.Add(XL.XlFormatConditionType.xlCellValue, XL.XlFormatConditionOperator.xlBetween, Formula1: low, Formula2: high);
            }
            this.ComObj.FormatConditions[this.ComObj.FormatConditions.Count].Interior.Color = color;
        }

        public void AddConditionalUnique(Sd.Color color, bool flip = false)
        {
            XL.UniqueValues unique = this.ComObj.FormatConditions.AddUniqueValues();
            if (flip)
            {
                unique.DupeUnique = XL.XlDupeUnique.xlDuplicate;
            }
            else
            {
                unique.DupeUnique = XL.XlDupeUnique.xlUnique;
            }
            unique.Interior.Color = color;
        }

        public void AddConditionalTopCount(int count, Sd.Color color, bool flip = false)
        {
            XL.Top10 top = this.ComObj.FormatConditions.AddTop10();
            top.Percent = false;
            top.Rank = count;
            if (flip)
            {
                top.TopBottom = XL.XlTopBottom.xlTop10Bottom;
            }
            else
            {
                top.TopBottom = XL.XlTopBottom.xlTop10Top;
            }
            top.Interior.Color = color;
        }

        public void AddConditionalTopPercent(double percent, Sd.Color color, bool flip = false)
        {
            percent = Math.Min(percent, 1.0);
            percent = Math.Max(percent, 0.0);
            XL.Top10 top = this.ComObj.FormatConditions.AddTop10();
            top.Percent = true;
            top.Rank = (int)(percent*100.0);
            if (flip)
            {
                top.TopBottom = XL.XlTopBottom.xlTop10Bottom;
            }
            else
            {
                top.TopBottom = XL.XlTopBottom.xlTop10Top;
            }
            top.Interior.Color = color;
        }

        public void AddConditionalBlanks(Sd.Color color, bool flip = false)
        {

            if (flip)
            {
                this.ComObj.FormatConditions.Add(XL.XlFormatConditionType.xlNoBlanksCondition);
            }
            else
            {
                this.ComObj.FormatConditions.Add(XL.XlFormatConditionType.xlBlanksCondition);
            }
            this.ComObj.FormatConditions[this.ComObj.FormatConditions.Count].Interior.Color = color;
        }

        public void AddConditionalScale(Sd.Color first, Sd.Color second, Sd.Color third, double mid = 0.5)
        {
            mid = Math.Min(mid, 1.0);
            mid = Math.Max(mid, 0.0);
            XL.ColorScale scale = this.ComObj.FormatConditions.AddColorScale(3);

            scale.ColorScaleCriteria[1].Type = XL.XlConditionValueTypes.xlConditionValueLowestValue;
            scale.ColorScaleCriteria[1].FormatColor.Color = first;

            scale.ColorScaleCriteria[2].Type = XL.XlConditionValueTypes.xlConditionValuePercentile;
            scale.ColorScaleCriteria[2].Value = (int)(mid*100.0);
            scale.ColorScaleCriteria[2].FormatColor.Color = second;

            scale.ColorScaleCriteria[3].Type = XL.XlConditionValueTypes.xlConditionValueHighestValue;
            scale.ColorScaleCriteria[3].FormatColor.Color = third;
        }

        public void AddConditionalScale(Sd.Color first, Sd.Color second)
        {
            XL.ColorScale scale = this.ComObj.FormatConditions.AddColorScale(2);
            int count = this.ComObj.FormatConditions.Count;

            scale.ColorScaleCriteria[1].Type = XL.XlConditionValueTypes.xlConditionValueLowestValue;
            scale.ColorScaleCriteria[1].FormatColor.Color = first;

            scale.ColorScaleCriteria[2].Type = XL.XlConditionValueTypes.xlConditionValueHighestValue;
            scale.ColorScaleCriteria[2].FormatColor.Color = second;
        }

        public void AddConditionalBar(Sd.Color color, bool gradient)
        {
            XL.Databar bar = this.ComObj.FormatConditions.AddDatabar();

            bar.BarColor.Color = color;
            if (gradient)
            {
                bar.BarFillType = XL.XlDataBarFillType.xlDataBarFillGradient;
            }
            else
            {
                bar.BarFillType = XL.XlDataBarFillType.xlDataBarFillSolid;
            }

        }

        #endregion

        #endregion

        #region overrides

        public override string ToString()
        {
            return this.start.Address+":"+this.extent.Address;
        }

        #endregion

    }
}
hmywillstronger
关注
  • 17
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Android Studio Bumblebee (android-studio-2021.1.1.22-windows)
03-03
Android Studio Bumblebee 2021.1.1 Patch 2 (android-studio-2021.1.1.22-windows.exe)大黄蜂，适用于Windows x86_64系统，是Android Studio 4.3（Android Studio Arctic Fox 2020.3.1.26新版本命名）版本之后的新...
Android Studio Bumblebee (android-studio-2021.1.1.22-mac.dmg)
03-03
Android Studio Bumblebee 2021.1.1 Patch 2 (android-studio-2021.1.1.22-mac.dmg)大黄蜂，适用于macOS Intel芯片系统，是Android Studio 4.3（Android Studio Arctic Fox 2020.3.1.26新版本命名）版本之后的新版本...
【C#】【EXCEL】Bumblebee/Classes/Marshal2.cs
hmywillstronger的博客
08-25 348
这个流程图将描述 方法的执行过程。成功 / Success失败 / Failure开始 / Start调用 GetActiveObject / Call GetActiveObject尝试 CLSIDFromProgIDEx / Try CLSIDFromProgIDEx获取 CLSID / Get CLSID调用 CLSIDFromProgID / Call CLSIDFromProgID调用 GetActiveObject / Call GetActiveObject返回对象 / Return Obj
【C#】【EXCEL】Bumblebee/Classes/ExApp.cs
hmywillstronger的博客
08-24 760
的类，它是对 Microsoft Excel 应用程序的封装。这个类提供了一系列方法来操作 Excel 应用程序、工作簿和工作表。获取或创建 Excel 应用程序 (Get or Create Excel Application)创建 ExApp 实例 (Create ExApp Instance)工作表操作 (Worksheet Operations)工作簿操作 (Workbook Operations)成功 / Success。失败 / Failure。开始 / Start。Excel 应用程序。
【C#】【EXCEL】Bumblebee/Classes/ExWorkbook.cs
hmywillstronger的博客
08-25 573
这个类提供了一个强大的接口来操作 Excel 工作簿,包括管理工作表、保存文件、添加和运行宏等功能。它封装了许多底层的 Excel COM 操作,使得在 .NET 环境中处理 Excel 文件变得更加简单和直观。: 设置 COM 对象和名称。这段代码现在包含了详细的中文注释，解释了每个方法和属性的功能。ExWorkbook Class (ExWorkbook类)获取指定名称的工作表,如果不存在则创建新的。获取活动工作表,如果没有则创建新的。从现有 ExWorkbook 创建。创建空 ExWorkbook。
【C#】【EXCEL】Bumblebee/Classes/ExEnums.cs
hmywillstronger的博客
08-25 469
这个流程图展示了 Bumblebee 命名空间中定义的各种枚举类型。Bumblebee 命名空间。
【C#】【EXCEL】Bumblebee/Classes/ExGraphic.cs
hmywillstronger的博客
08-25 461
根据您提供的代码和要求，我将创建一个流程图来展示ExGraphic类的结构。这个流程图将使用中英双语标注，并对应到代码中的英文。这个流程图清晰地展示了ExGraphic类的结构，包括已定义的成员变量以及尚未实现的构造函数、属性和方法。这个类旨在封装与图形相关的各种属性和方法。这个流程图展示了ExGraphic类的结构。ExGraphic Class (ExGraphic 类)潜在的构造函数、属性和方法的示例。Members (成员变量)ExGraphic 类。成员变量的用途和默认值。
【C#】【EXCEL】Bumblebee/Classes/ExShape.cs
hmywillstronger的博客
08-25 571
这些方法和属性共同构成了一个强大的接口,用于在C#中操作Excel形状,特别是SmartArt对象。它们展示了如何与Excel的COM对象交互,修改形状的各种属性,如颜色、线条粗细和布局。这个类的设计考虑到了易用性和灵活性,允许开发者精确控制Excel中的图形元素。这个方法重写了Object类的ToString方法,提供了ExShape对象的自定义字符串表示。当然,我会为这段代码添加详细的中文注释,以便于您的学习和博客发表。这个方法设置形状轮廓的颜色。它同时设置线条的前景色和背景色,以确保一致的颜色效果。
【C#】【EXCEL】Bumblebee/Classes/ExFont.cs
hmywillstronger的博客
08-25 427
这个流程图展示了ExFont类的结构，包括已定义的成员变量以及尚未实现的构造函数、属性和方法。成员变量部分详细列出了每个变量的名称、类型和中文说明，直接对应到代码中的英文。根据您提供的代码和要求，我将创建一个流程图来展示ExFont类的结构。这个类可以用在需要频繁操作字体属性的场景，如文本编辑器、报表生成器等。这个类旨在封装与字体相关的各种属性，如字体族、颜色、样式等。通过这种方式，可以深入探讨ExFont类的设计理念、实现细节和潜在应用。流程图展示了ExFont类的结构。Members (成员变量)
【C#】【EXCEL】Bumblebee/Classes/ExData.cs
hmywillstronger的博客
08-25 706
它包含一个枚举来定义可能的数据类型，一个受保护的成员来存储当前类型，两个构造函数用于不同的初始化方式，以及一个属性来获取数据类型。好的，我会为您创建一个描述 ExData 抽象类结构的流程图，包含中英双语说明。ExData 抽象类定义完成 / ExData Abstract Class Defined。当然，我会为您提供流程图和代码的详细解释，并用中英双语实现解释和代码的对应。整个类的结构已经定义完成，包括所有必要的成员、构造函数和属性。这是整个类的开始，定义了一个名为 ExData 的抽象类。
【C#】【EXCEL】Bumblebee/Classes/ExCell.cs
hmywillstronger的博客
08-24 607
地址转换操作 / Address Conversion Operations。创建 ExCell 实例 / Create ExCell Instance。这主要对应于 Address 属性的 get 和 set 方法。根据需求选择不同的构造函数来创建 ExCell 实例。这是流程的起点，代表我们开始使用 ExCell 类。属性操作 / Property Operations。虽然流程图中没有直接显示，但这些是类的基础。这对应于代码中的构造函数部分。获取/设置 Address。这对应于代码中的属性部分。
Android Studio Bumblebee (android-studio-2021.1.1.22-cros.deb)
03-03
Android Studio Bumblebee 2021.1.1 Patch 2 (android-studio-2021.1.1.22-cros.deb)大黄蜂，适用于Chrome OS系统，是Android Studio 4.3（Android Studio Arctic Fox 2020.3.1.26新版本命名）版本之后的新版本...
【C#】【EXCEL】Bumblebee/Components/Analysis/GH_Ex_Ana_CondBar.cs
最新发布
hmywillstronger的博客
08-25 372
这段代码定义了一个名为的 Grasshopper 组件，其主要功能是为 Excel 工作表中的特定范围添加条件格式条形。以下是该组件的主要功能和特点：组件特性：作为次要组件显示在 Grasshopper 界面中具有自定义图标有唯一的组件标识符（GUID）组件标识符（GUID）在 Grasshopper 插件开发中有几个重要的目的：唯一标识：GUID 确保每个组件在 Grasshopper 环境中都有一个唯一的标识符。这对于区分不同的组件至关重要，即使它们可能有相似的名称或功能。
C＃与其它编程语言有什么区别，以及相关优势有哪些
probably121的博客
08-19 696
C#编程语言的主要特性包括**面向对象、统一的类型系统、自动内存管理等**。与其它编程语言相比，C#的优势体现在**跨平台开发支持、强大的语言集成查询（LINQ）功能、高效的性能**这几个方面。通过.NET Core，C#可以实现真正的跨平台开发，这是其相对于许多其他语言的重要优势。LINQ提供了强大的数据查询能力，使得处理数据变得简单而高效。该语言拥有一个统一的类型系统，可以进行无缝的类型转换。尽管C#是一种安全的编程语言，但它仍能提供高效的性能。C#的语言集成查询提供了强大的数据查询能力。
C# 项目管理CLI常用命令
yuwoxinanA3的博客
08-24 194
.NET Command Line Interface (CLI) 是一个跨平台的工具链，用于开发、构建、运行和发布基于 .NET Core 和 .NET 5+ 应用程序。以下是一些常用的 .NET CLI 命令及其简要说明
Python3学习（一）
qq_54161774的博客
08-21 1254
python的基础语法
C# 匿名函数 delegate（参数...）{ }
m0_53393728的博客
08-25 201
什么是匿名函数顾名思义，就是没有名字的函数匿名函数的使用主要是配合委托和事件进行使用脱离委托和事件 是不会使用匿名函数的基本语法delegate (参数列表)函数逻辑何时使用？1.函数中传递委托参数时2.委托或事件赋值时。
ERROR: Exception: Traceback (most recent call last): File "/usr/lib/python3/dist-packages/pip/_internal/cli/base_command.py", line 186, in _main status = self.run(options, args) File "/usr/lib/python3/dist-packages/pip/_internal/commands/freeze.py", line 100, in run for line in freeze(**freeze_kwargs): File "/usr/lib/python3/dist-packages/pip/_internal/operations/freeze.py", line 70, in freeze req = FrozenRequirement.from_dist(dist) File "/usr/lib/python3/dist-packages/pip/_internal/operations/freeze.py", line 257, in from_dist req = dist.as_requirement() File "/home/zust/.local/lib/python3.8/site-packages/pkg_resources/__init__.py", line 2919, in as_requirement if isinstance(self.parsed_version, packaging.version.Version): File "/home/zust/.local/lib/python3.8/site-packages/pkg_resources/__init__.py", line 2735, in parsed_version raise packaging.version.InvalidVersion(f"{str(ex)} {info}") from None pkg_resources.extern.packaging.version.InvalidVersion: Invalid version: '0.23ubuntu1' (package: distro-info)
07-25
这个错误是由于安装的软件包 "distro-info" 的版本号出现问题导致的。版本号 "0.23ubuntu1" 被认为是无效的。你可以尝试通过升级或重新安装 "distro-info" 来解决这个问题。你可以使用以下命令尝试解决： ``` pip install --upgrade distro-info ``` 如果升级不起作用，你可以尝试卸载并重新安装 "distro-info"： ``` pip uninstall distro-info pip install distro-info ``` 如果问题仍然存在，请检查你的环境是否存在其他与 "distro-info" 相关的软件包或依赖项，并确保它们的版本号是有效的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

hmywillstronger

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值