EA 插件开发，winfrom dataGridView1 异步逐行添加数据

最新推荐文章于 2023-09-11 15:00:52 发布
最新推荐文章于 2023-09-11 15:00:52 发布
阅读量284 收藏 2
点赞数
分类专栏： c# 文章标签： c# winform EA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lizhihua0625/article/details/131242823
版权
此代码示例展示了如何使用异步方法从数据库加载数据到WindowsForms应用程序中的DataGridView控件。它使用BackgroundWorker组件来避免阻塞UI线程，并处理用户点击和右键点击事件。同时，它还涉及与EnterpriseArchitect(EA)的集成，如图谱和连接线的处理。
摘要由CSDN通过智能技术生成 
using EA;
using Microsoft.Office.Interop.Excel;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using static System.Windows.Forms.VisualStyles.VisualStyleElement;
using static UmlDemo1.UserControlFeatureList;

namespace UmlDemo1
{
    public partial class UserControlFeatureList : UserControl
    {
        public UserControlFeatureList()
        {
            InitializeComponent();
            // Add CellClick event listener
            dataGridView1.CellClick += new DataGridViewCellEventHandler(dataGridView1_CellClick);
            // 监听鼠标右键事件
            dataGridView1.MouseClick += new MouseEventHandler(dataGridView1_MouseClick);
        }
        public class Person
        {
            public string 系统 { get; set; }

            public string 功能 { get; set; }

            public string Note { get; set; }
        }
        private System.ComponentModel.BackgroundWorker worker;
        private delegate void AddDataGridViewRowDelegate(Person person);
        private async void UserControlFeatureList_Load(object sender, EventArgs e)
        {
            pictureBox1.Visible = true;
            //dataGridView1.Visible = false;
            // 先显示窗口
            this.Show();
            Control.CheckForIllegalCrossThreadCalls = false;
            // 实例化后台工作线程组件
            worker = new System.ComponentModel.BackgroundWorker();
            worker.DoWork += DoWork;
            worker.RunWorkerAsync();
            // 设置 ComboBoxControlType 的默认值为 "关系类型"
            comboBoxConnector_Type.SelectedItem = "关系类型";
            toolStripStatusLabel1.Text = "";

        }
        private int _dotIndex = 0;
        private enum Status { Busy, Ready };
        private Timer _timer;
        private System.Windows.Forms.Timer _hideProgressBarTimer;
        private void UpdateStatus(Status status)
        {
            if (this.statusStrip1.InvokeRequired)
            {
                this.statusStrip1.Invoke(new MethodInvoker(delegate { this.UpdateStatus(status); }));
            }
            else
            {
                switch (status)
                {
                    case Status.Busy:
                        _dotIndex = (_dotIndex + 1) % 4;
                        toolStripStatusLabel1.Text = "忙碌中" + new string('.', _dotIndex);
                        _timer.Start();
                        
                        break;
                    case Status.Ready:
                        toolStripStatusLabel1.Text = "";                        
                        _timer.Stop();
                        _hideProgressBarTimer.Start();
                        break;
                }
            }
        }

        private void _timer_Tick(object sender, EventArgs e)
        {
            _dotIndex = (_dotIndex + 1) % 4;
            toolStripStatusLabel1.Text = "忙碌中" + new string('.', _dotIndex);
        }
        private void _timer_hideProgressBar(object sender, EventArgs e)
        {
            toolStripProgressBar1.Visible = false;
            _hideProgressBarTimer.Stop();
        }

        private void DoWork(object sender, System.ComponentModel.DoWorkEventArgs e)
        {
            // 设置进度条最大值为100
            toolStripProgressBar1.Maximum = Maximum;
            // 设置进度条步长为1
            toolStripProgressBar1.Step = 1;
            _timer = new Timer();
            _timer.Interval = 500; // 设置定时器间隔为500ms
            _timer.Tick += _timer_Tick;

            _hideProgressBarTimer = new System.Windows.Forms.Timer();
            _hideProgressBarTimer.Interval = 3000; // 设置定时器间隔为 3000ms
            _hideProgressBarTimer.Tick += _timer_hideProgressBar;

            // 更新状态栏为忙碌状态
            UpdateStatus(Status.Busy);
            // 模拟异步加载数据，逐行添加到DataGridView控件中
            for (int i = 0; i < Maximum; i++)
            {
                // 模拟异步加载数据需要一定的时间
                System.Threading.Thread.Sleep(100);

                var rowValue1 = $"第{i}行列1";
                var rowValue2 = $"第{i}行列2";
                Person person = new Person() { 系统 = "王五"+i, 功能 = "" + i, Note = "男" + i };
                // 添加数据到DataGridView控件中
                AddDataGridViewRow(person);                
            }
            // 更新状态栏为就绪状态
            UpdateStatus(Status.Ready);
        }

        private void AddDataGridViewRow(Person person)
        {
            if (this.dataGridView1.InvokeRequired)
            {
                // 如果是异步后台线程触发的，那么需要通过委托回调通知UI线程更新DataGridView控件中的数据
                this.Invoke(new AddDataGridViewRowDelegate(AddDataGridViewRow), new object[] { person });
            }
            else
            {
                // 在UI线程中更新DataGridView控件中的数据
                if (dataGridView1.Rows.Count > 0)
                {
                    DataGridViewRow row = (DataGridViewRow)dataGridView1.Rows[0].Clone();
                }                
                //row.Cells["系统"].Value = arg1;
                //row.Cells["功能"].Value = arg2;
                dataGridView1.Rows.Add(person.系统, person.功能, person.Note);
                toolStripProgressBar1.PerformStep();
            }
        }

        private void dataGridView1_CellClick(object sender, DataGridViewCellEventArgs e)
        {
            DataGridView_CellClick(sender, e, dataGridView1);
        }
        private void dataGridView1_MouseClick(object sender, MouseEventArgs e)
        {
            DataGridView_MouseClick(sender, e, dataGridView1);
        }
        private void contextMenuStrip1_Opening(object sender, CancelEventArgs e)
        {

        }

        
        private void DataGridView_CellClick(object sender, DataGridViewCellEventArgs e, DataGridView dgv)
        {
            // && e.ColumnIndex >= 0)
            // Make sure the clicked cell is valid
            if (e.RowIndex >= 0)
            {
                DataGridViewRow row = dgv.Rows[e.RowIndex];
                if (e.ColumnIndex >= 0)
                {
                    DataGridViewCell cell = row.Cells[e.ColumnIndex];
                }
                string DiagramID = "";
                if (dgv.Columns.Contains("DiagramID") && row.Cells["DiagramID"].Value != null)
                {
                    DiagramID = row.Cells["DiagramID"].Value.ToString();
                }
                try
                {
                    if (DiagramID != "")
                    {
                        EA.Diagram diagram = repository.GetDiagramByID(int.Parse(DiagramID));
                        if (diagram != null)
                        {
                            repository.ShowInProjectView(diagram);
                        }
                    }

                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }


            }


        }

        // 单击右键时，在合适的位置弹出contextMenuStrip1
        private void DataGridView_MouseClick(object sender, MouseEventArgs e, DataGridView dgv)
        {
            if (e.Button == MouseButtons.Right)
            {
                // 获取当前鼠标单击的位置
                System.Drawing.Point location = dgv.PointToClient(Cursor.Position);
                // 获取鼠标点击位置
                DataGridView.HitTestInfo hti = dgv.HitTest(e.X, e.Y);
                if (hti.Type == DataGridViewHitTestType.Cell)
                {
                    // 设置当前单元格为选中状态
                    dgv.CurrentCell = dgv.Rows[hti.RowIndex].Cells[hti.ColumnIndex];
                    // 设置当前行为选中状态
                    dgv.Rows[hti.RowIndex].Selected = true;
                    // 弹出右键菜单
                    contextMenuStrip1.Show(dgv, location);
                }
            }
        }

        private EA.Repository repository = null;
        private string title = "";
        private string comboBoxConnector_Type_SelectedItem = null;
        private int Maximum = 120;
        public async void ShowList(EA.Repository repository, string title, DateTime? startTimeVal = null, DateTime? endTimeVal = null)
        {
            this.repository = repository;
            this.title = title;
            DateTime today = DateTime.Now; //获取当前日期
            DateTime lastDay = today.AddDays(-30); //获取当前日期的前一天
            if (startTimeVal == null)
            {
                startTimeVal = lastDay;
            }
            if (endTimeVal == null)
            {
                endTimeVal = today;
            }
            string sql = null;
            PublicClass publicClass1 = new PublicClass();


            // 获取关系类型   comboBoxConnector_Type                      
            if (comboBoxConnector_Type.Items.Count <= 1)
            {
                List<Dictionary<string, string>> dataListElementType = await System.Threading.Tasks.Task.Run(() =>
                {
                    string sql1 = "SELECT DISTINCT Connector_Type FROM `t_connector`";
                    return publicClass1.Sql2Xml(repository, sql1);
                });
                comboBoxConnector_Type.Items.Clear();
                comboBoxConnector_Type.Items.Add("关系类型");
                foreach (var item in dataListElementType)
                {
                    comboBoxConnector_Type.Items.Add(item["Connector_Type"]);
                }
                comboBoxConnector_Type.SelectedItem = "关系类型";
            }
            if (comboBoxConnector_Type.SelectedItem != null || comboBoxConnector_Type.SelectedItem != "关系类型")
            {
                this.comboBoxConnector_Type_SelectedItem = comboBoxConnector_Type.SelectedItem.ToString();
            }
            switch (title)
            {
                case "功能列表":
                    //List<Dictionary<string, string>> DataFlowList = await GetFeatureList(repository, startTimeVal, endTimeVal);
                    //publicClass1.LoadDataElements(dataGridView1, DataFlowList);
                    pictureBox1.Visible = false;
                    dataGridView1.Visible = true;

                    break;

                default:
                    break;

            }


        }

        private async Task<List<Dictionary<string, string>>> getDiagramList(EA.Repository repository)
        {
            List<Dictionary<string, string>> dataList = new List<Dictionary<string, string>>();
            try
            {
                string sql = null;
                PublicClass publicClass1 = new PublicClass();
                // 异步执行耗时操作
                dataList = await System.Threading.Tasks.Task.Run(() =>
                {
                    string Package_ID_str = publicClass1.GetChindPackages(repository);
                    sql = "SELECT 'diagram' as BelongsType,t.Package_ID,p.Parent_ID,p.`Name` as Package_Name,t.CreatedDate, t.ModifiedDate, t.Diagram_ID, t.Name AS Diagram_Name, t.Diagram_Type,t.Author as author,t.Stereotype FROM t_diagram t left join t_package p on t.Package_ID=p.Package_ID WHERE 1 ";
                    if (Package_ID_str != "")
                    {
                        sql = sql + " and t.Package_ID in(" + Package_ID_str + ") ";
                    }
                    sql = sql + " order by t.Diagram_ID desc";
                    Console.WriteLine(sql);
                    // 耗时操作代码，例如访问网络、读写文件等
                    return publicClass1.Sql2Xml(repository, sql);
                });
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
            return dataList;
        }

        private async Task<List<Dictionary<string, string>>> getConnectorList(EA.Repository repository, List<Dictionary<string, string>> DiagramList)
        {
            List<Dictionary<string, string>> connectorList = new List<Dictionary<string, string>>();
            foreach (var dataDict in DiagramList)
            {
                EA.Diagram currentDiagram = repository.GetDiagramByID(int.Parse(dataDict["Diagram_ID"]));
                if (currentDiagram == null)
                {
                    continue;
                }
                // Iterate through the diagram links in the current diagram
                foreach (EA.DiagramLink diagramLink in currentDiagram.DiagramLinks)
                {
                    Dictionary<string, string> rowDict = new Dictionary<string, string>(); // 新建一个字典，保存每个数据行的属性值
                    rowDict["DiagramID"] = currentDiagram.DiagramID.ToString();
                    rowDict["DiagramObjects"] = currentDiagram.ObjectType.ToString();
                    rowDict["CreatedDate"] = currentDiagram.CreatedDate.ToString();
                    rowDict["ModifiedDate"] = currentDiagram.ModifiedDate.ToString();
                    rowDict["ConnectorID"] = "";
                    rowDict["Direction"] = "";
                    rowDict["fangxiang"] = "";
                    rowDict["Type"] = "";
                    rowDict["MetaType"] = "";
                    rowDict["ConveyedItems"] = "";
                    rowDict["sourceElementName"] = "";
                    rowDict["ParentSourceElementName"] = "";
                    rowDict["targetElementName"] = "";
                    rowDict["ParentTargetElementName"] = "";
                    // 如果它的源 ID 和目标 ID 与element 的ID匹配，则将其打印出来
                    if (diagramLink != null && diagramLink.ConnectorID > 0)
                    {
                        EA.Connector connector = null;
                        try
                        {
                            connector = repository.GetConnectorByID(diagramLink.ConnectorID);
                        }
                        catch
                        {
                        }
                        if (connector == null)
                        {
                            continue;
                        }

                        if (connector != null)
                        {
                            if (comboBoxConnector_Type_SelectedItem != null|| comboBoxConnector_Type_SelectedItem != "关系类型")
                            {
                                if (comboBoxConnector_Type_SelectedItem != connector.Type.ToString())
                                {
                                    continue;
                                }
                            }
                            rowDict["ConnectorID"] = connector.ConnectorID.ToString();
                            rowDict["Direction"] = connector.Direction.ToString();
                            rowDict["MetaType"] = connector.MetaType.ToString();
                            rowDict["Type"] = connector.Type.ToString();
                            if (rowDict["Direction"].Contains("->"))
                            {
                                rowDict["fangxiang"] = "->";
                            }
                            List<string> arr1 = new List<string>();
                            foreach (dynamic item in connector.ConveyedItems)
                            {
                                if (item != null && item.Name != null)
                                {
                                    arr1.Add(item.Name.ToString());
                                }
                            }
                            rowDict["ConveyedItems"] = string.Join(",", arr1);
                            //rowDict["ConveyedItems"] = string.Join(",", connector.ConveyedItems.Select(item => item.Name).Aggregate((current, next) => current + "," + next));
                            // 获取 Source 和 Target 对象的 Element 对象
                            EA.Element sourceElement = repository.GetElementByID(connector.ClientID);
                            if (sourceElement != null)
                            {
                                rowDict["sourceElementName"] = sourceElement.Name;
                                if (sourceElement.ParentID > 0)
                                {
                                    EA.Element ParentSourceElement = repository.GetElementByID(sourceElement.ParentID);
                                    if (ParentSourceElement != null)
                                    {
                                        rowDict["ParentSourceElementName"] = ParentSourceElement.Name;
                                    }
                                }
                            }
                            EA.Element targetElement = repository.GetElementByID(connector.SupplierID);
                            if (targetElement != null)
                            {
                                rowDict["targetElementName"] = targetElement.Name;
                                if (targetElement.ParentID > 0)
                                {
                                    EA.Element ParentTargetElement = repository.GetElementByID(targetElement.ParentID);
                                    if (ParentTargetElement != null)
                                    {
                                        rowDict["ParentTargetElementName"] = ParentTargetElement.Name;
                                    }
                                }
                            }
                        }
                        connectorList.Add(rowDict);



                        //    // 获取该连接线的目标元素（Target）
                        //    EA.Element targetElement = repository.GetElementByGuid(diagramLink.TargetInstanceUID);
                        //    if (targetElement != null)
                        //    {
                        //        // 获取连接线的Geometry信息，包括箭头方向信息
                        //        string geometry = diagramLink.Geometry;
                        //        // 此处根据geometry信息获取箭头属性等其他信息
                        //        Console.WriteLine($"连接线从 {targetElement.Name} 到 {targetElement.Name}，箭头方向为 {geometry}。");

                        //    }

                    }
                }
            }
            return connectorList;
        }

        private async Task<List<Dictionary<string, string>>> GetFeatureList(EA.Repository repository, DateTime? startTimeVal = null, DateTime? endTimeVal = null)
        {
            List<Dictionary<string, string>> diagramList = await getDiagramList(repository);
            Console.WriteLine(diagramList);
            List<Dictionary<string, string>> connectorList = await getConnectorList(repository, diagramList);
            Console.WriteLine(connectorList);
            return connectorList;
        }
        private void exportExcel_Click(object sender, EventArgs e)
        {
            MessageBox.Show("导出数据");
            PublicClass publicClass1 = new PublicClass();
            publicClass1.doExportExcel(dataGridView1);
        }

        private void comboBoxConnector_Type_SelectedIndexChanged(object sender, EventArgs e)
        {
            pictureBox1.Visible = true;
            dataGridView1.Visible = false;
            // 获取当前标签页的title
            ShowList(repository, title);
        }

        private void findInBrowserToolStripMenuItem_Click(object sender, EventArgs e)
        {
            EA.Element element = repository.GetTreeSelectedObject() as EA.Element; // 获取当前选中的元素
            EA.Package selectedPackage = repository.GetTreeSelectedPackage() as EA.Package;
            bool isDiagram = false;
            EA.Diagram currentDiagram = null;
            if (element != null)
            {
                // 选择tree中的元素
                this.repository.ShowInProjectView(element);
            }
        }

        private void findInDiagramToolStripMenuItem_Click(object sender, EventArgs e)
        {
            EA.Element element = repository.GetTreeSelectedObject() as EA.Element; // 获取当前选中的元素
            EA.Package selectedPackage = repository.GetTreeSelectedPackage() as EA.Package;
            bool isDiagram = false;
            EA.Diagram currentDiagram = null;
            if (element != null)
            {
                // 选择tree中的元素
                this.repository.ShowInProjectView(element);
                foreach (EA.Diagram dia in element.Diagrams)
                {
                    Console.WriteLine("dia.Name=====" + dia.Name);
                }
                EA.Diagram dia0 = repository.GetContextObject() as EA.Diagram;
                if (dia0 != null && dia0.DiagramObjects.Cast<EA.DiagramObject>().Any(dobj => dobj.ElementID == element.ElementID))
                {
                    // 当前 diagram 包含当前元素
                    Console.WriteLine("dia0=====" + dia0.Name);
                    isDiagram = true;
                    currentDiagram = dia0;

                }
                EA.Diagram dia1 = this.repository.GetCurrentDiagram();
                if (dia1 != null && !isDiagram)
                {
                    isDiagram = true;
                    currentDiagram = dia1;
                }
            }
            if (selectedPackage != null && !isDiagram)
            {
                // 获取 Package 中的所有图表
                foreach (EA.Diagram dia2 in selectedPackage.Diagrams)
                {
                    if (dia2 != null)
                    {
                        isDiagram = true;
                        currentDiagram = dia2;
                        break;
                    }
                }
            }
            if (isDiagram)
            {
                repository.OpenDiagram(currentDiagram.DiagramID);
                if (element != null)
                {
                    // 选中元素在项目浏览器中的位置
                    string location = string.Format("EAID={0}", element.ElementID);
                    // 将元素在 diagram 上的位置设置为当前选中元素
                    currentDiagram.FindElementInDiagram(element.ElementID);
                }

                //EA.DiagramObject diaObject = currentDiagram.GetDiagramObjectByID(element.ElementID, "");
                //diaObject.ElementID = element.ElementID;
                //diaObject.ShowNotes = true;
                //diaObject.ShowTags = true;
                //diaObject.Update();
                //currentDiagram.Update();
                 切换到该 diagram 并刷新界面
                //repository.OpenDiagram(currentDiagram.DiagramID);
                //repository.RefreshOpenDiagrams(true);

            }
        }

        private void btnReset_Click(object sender, EventArgs e)
        {
            comboBoxConnector_Type.SelectedItem = null;
            comboBoxConnector_Type_SelectedItem = null;
            DateTime startTimeVal = DateTime.Now.AddDays(-30);
            DateTime endTimeVal = DateTime.Now;
            ShowList(repository, title, startTimeVal, endTimeVal);
        }

        
    }
}


using EA;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Xml.Linq;
using static UmlDemo1.FormUnnamedElements;

namespace UmlDemo1
{

    public class XmlElementData
    {
        public string Name { get; set; }             // 元素名 
        public Dictionary<string, string> Values
        {   // 属性名和对应的值
            get; set;
        }

        public XmlElementData()
        {
            Values = new Dictionary<string, string>();
        }
    }

    public class PublicClass
    {  
        public List<Dictionary<string, string>> Sql2Xml(EA.Repository repository, string sql)
        {
            //List<XmlElementData> dataList = new List<XmlElementData>(); // 存储所有解析得到的元素
            List<Dictionary<string, string>> dataList = new List<Dictionary<string, string>>(); // 初始化保存结果的列表
            if (sql == "" || sql == null|| repository == null)
            {
                return dataList;
            }
            sql = sql.Replace("\r\n", " ");
            sql = string.Format(sql);
            if (sql!="")
            {
                try
                {
                    string xmlResult = repository.SQLQuery(sql);
                    XDocument doc = XDocument.Parse(xmlResult);    // 将查询结果解析为 XDocument 对象
                                                                   // 对解析得到的 XML 数据进行遍历和处理            
                    if (doc.Root.Element("Dataset_0") == null)
                    {
                        return dataList;
                    }
                    if (doc.Root.Element("Dataset_0").Element("Data") == null)
                    {
                        return dataList;
                    }
                    if (doc.Root.Element("Dataset_0").Element("Data").Elements("Row") == null)
                    {
                        return dataList;
                    }
                    // 遍历每个数据行（Row 元素）
                    foreach (XElement rowElement in doc.Root.Element("Dataset_0").Element("Data").Elements("Row"))
                    {
                        Dictionary<string, string> rowDict = new Dictionary<string, string>(); // 新建一个字典，保存每个数据行的属性值

                        // 遍历数据行中的每个属性，将属性名和属性值保存到字典中
                        foreach (XElement attrElement in rowElement.Elements())
                        {
                            rowDict[attrElement.Name.LocalName] = attrElement.Value;
                        }

                        dataList.Add(rowDict); // 将保存了该数据行属性值的字典添加到列表中
                    }
                }
                catch(Exception e)
                {
                    MessageBox.Show(e.Message);
                }
                
            }
            Console.Write(sql);
            return dataList;

        }

        private List<EA.Package> GetAllSubPackages(EA.Package package)
        {
            List<EA.Package> subPackages = new List<EA.Package>();
            foreach (EA.Package subPackage in package.Packages)
            {
                subPackages.Add(subPackage);
                subPackages.AddRange(GetAllSubPackages(subPackage));
            }
            return subPackages;
        }

        public string GetChindPackages(EA.Repository repository)
        {
            int Package_ID = 0;
            string Package_ID_arr2str = "";
            List<int> Package_ID_arr = new List<int>();
            EA.Package selectedPackage = repository.GetTreeSelectedPackage() as EA.Package;
            if (selectedPackage != null && selectedPackage.PackageID > 1)
            {
                Package_ID = selectedPackage.PackageID;
                if (Package_ID > 1)
                {
                    Package_ID_arr.Add(Package_ID);
                    List<EA.Package> allSubPackages = GetAllSubPackages(selectedPackage);
                    foreach (var item in allSubPackages)
                    {
                        Package_ID_arr.Add(item.PackageID);
                    }
                }
            }
            Package_ID_arr2str = string.Join(",", Package_ID_arr.Select(x => x.ToString()).ToArray());
            return Package_ID_arr2str;
        }
        public void LoadDataElements(DataGridView dgv, List<Dictionary<string, string>> dataList)
        {
            dgv.Rows.Clear();

            // 遍历数据源中的每个项，并向 DataGridView 中添加新行
            foreach (var dataDict in dataList)
            {
                DataGridViewRow row = new DataGridViewRow();
                row.CreateCells(dgv);

                // 针对每个属性，在DataGridView中查找匹配的列，并将属性值分配给该列
                foreach (KeyValuePair<string, string> keyValue in dataDict)
                {
                    string attrName = keyValue.Key;
                    string attrValue = keyValue.Value;

                    // 在 DataGridView 中查找具有匹配名称的列
                    DataGridViewColumn col = dgv.Columns[attrName];

                    // 如果找到了匹配的列，则将属性值分配给它
                    if (col != null)
                    {
                        DataGridViewCell cell = row.Cells[col.Index];

                        if (cell.ValueType == typeof(DateTime))
                        {
                            DateTime dt;
                            if (DateTime.TryParse(attrValue, out dt))
                            {
                                cell.Value = dt;
                            }
                        }
                        else if (cell is DataGridViewCheckBoxCell)
                        {
                            bool isChecked = false;
                            if (bool.TryParse(attrValue, out isChecked))
                            {
                                cell.Value = isChecked;
                            }
                        }
                        else
                        {
                            cell.Value = attrValue;
                        }
                    }
                }

                // 将新行添加到 DataGridView 中
                dgv.Rows.Add(row);
            }
        }
        public void LoadDataElements1(DataGridView dgv, List<Dictionary<string, string>> dataList)
        {
            var rowsToDelete = new List<DataGridViewRow>();

            dgv.Rows.Clear();
            foreach (DataGridViewRow row in dgv.Rows)
            {
                if (!row.IsNewRow)
                {
                    bool foundRow = false;

                    // 遍历每个属性，将属性名和属性值添加到对应的 DataGridView 单元格中
                    foreach (KeyValuePair<string, string> keyValue in dataList[0])
                    {
                        string attrName = keyValue.Key;
                        string attrValue = string.Empty;

                        // Check if current row data has the attribute name
                        if (dataList[0].ContainsKey(attrName))
                        {
                            attrValue = dataList.First(k => k.ContainsKey(attrName))[attrName];

                            // Define the cell object
                            DataGridViewCell cell = row.Cells[attrName];

                            // 判断DataGridView中是否存在当前属性值
                            if (dgv.Columns.Contains(attrName) && cell != null)
                            {
                                // 判断当前属性类型，并针对类型进行单元格值的转换
                                if (cell.ValueType == typeof(DateTime))
                                {
                                    DateTime dt;
                                    if (DateTime.TryParse(attrValue, out dt))
                                    {
                                        cell.Value = dt;
                                    }
                                }
                                else if (cell is DataGridViewCheckBoxCell)
                                {
                                    bool isChecked = false;
                                    if (bool.TryParse(attrValue, out isChecked))
                                    {
                                        cell.Value = isChecked;
                                    }
                                }
                                else
                                {
                                    cell.Value = attrValue;
                                }

                                foundRow = true;
                            }
                        }
                    }

                    // 如果找不到符合条件的属性，就将当前行删除
                    if (!foundRow)
                    {
                        rowsToDelete.Add(row);
                    }
                }
            }

            // Remove rows doesn't exist in the data list
            rowsToDelete.ForEach(row => dgv.Rows.Remove(row));

            // 如果有未显示的属性，将它们添加到DataGridView中
            foreach (var dataDict in dataList)
            {
                bool foundRow = false;

                DataGridViewRow row = new DataGridViewRow();
                row.CreateCells(dgv);

                // 遍历每个属性，将属性名和属性值添加到对应的 DataGridView 单元格中
                foreach (KeyValuePair<string, string> keyValue in dataDict)
                {
                    string attrName = keyValue.Key;
                    string attrValue = keyValue.Value;
                    foreach (DataGridViewColumn col in dgv.Columns)
                    {
                        if (col.Name == attrName)
                        {
                            DataGridViewCell cell = row.Cells[col.Index];
                            // 判断当前属性类型，并针对类型进行单元格值的转换
                            if (cell.ValueType == typeof(DateTime))
                            {
                                DateTime dt;
                                if (DateTime.TryParse(attrValue, out dt))
                                {
                                    cell.Value = dt;
                                }
                            }else if (cell is DataGridViewCheckBoxCell)
                            {
                                bool isChecked = false;
                                if (bool.TryParse(attrValue, out isChecked))
                                {
                                    cell.Value = isChecked;
                                }
                            }
                            else
                            {
                                cell.Value = attrValue;
                            }
                            foundRow = true;
                            break;
                        }
                    } 
                }

                if (foundRow)
                {
                    dgv.Rows.Add(row);
                }
            }
        }

        public void doExportExcel(DataGridView dgv)
        {
            // 创建一个Excel对象
            Microsoft.Office.Interop.Excel.Application excel = new Microsoft.Office.Interop.Excel.Application();

            // 创建工作簿
            Microsoft.Office.Interop.Excel.Workbook workbook = excel.Workbooks.Add();

            // 创建工作表
            Microsoft.Office.Interop.Excel.Worksheet worksheet = workbook.ActiveSheet;

            // 将DataGridView导出到Excel
            for (int i = 0; i < dgv.ColumnCount; i++)
            {
                worksheet.Cells[1, i + 1] = dgv.Columns[i].HeaderText;
            }
            for (int i = 0; i < dgv.Rows.Count; i++)
            {
                for (int j = 0; j < dgv.Columns.Count; j++)
                {
                    if (dgv.Rows[i].Cells[j].Value != null)
                    {
                        worksheet.Cells[i + 2, j + 1] = dgv.Rows[i].Cells[j].Value.ToString();
                    }
                    else
                    {
                        worksheet.Cells[i + 2, j + 1] = "";
                    }
                }
            }

            // 打开Excel并显示数据
            excel.Visible = true;
        }


        private async Task<List<Dictionary<string, string>>> getDataList(EA.Repository repository,string sql)
        {
            List<Dictionary<string, string>> dataList = new List<Dictionary<string, string>>();
            try
            {
                if (sql != null && sql != "")
                {
                    // 异步执行耗时操作
                    dataList = await System.Threading.Tasks.Task.Run(() =>
                    {
                        //sql = "SELECT 'diagram' as BelongsType,t.Package_ID,p.Parent_ID,p.`Name` as Package_Name,t.CreatedDate, t.ModifiedDate, t.Diagram_ID, t.Name AS Diagram_Name, t.Diagram_Type,t.Author as author,t.Stereotype FROM t_diagram t left join t_package p on t.Package_ID=p.Package_ID WHERE 1 ";
                        Console.WriteLine(sql);
                        // 耗时操作代码，例如访问网络、读写文件等
                        return Sql2Xml(repository, sql);
                    });
                }
                
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
            return dataList;
        }













    }


}
puamac
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
.net中DataGridView异步加载大批量数据
06-08
多线程异步加载大批量数据到Datagridview中，没次加载1000条数据。 引用DLL，调用方法： string sql = "select top {0} * from {2} where FItemID not in (select top {1} FItemID from {2})"; string tbName = "b_material"; Dictionary dic = new Dictionary(); dic.Add("sql", sql); dic.Add("tbName", tbName); dic.Add("sqlConn", "server=192.168.1.254;user=sa;pwd='';database=APS20091223114023"); DgvShowPager d = new DgvShowPager(this.dataGridView1, dic); d.ShowDataPager(); 不明白的可以加我QQ：253874510
DataGridView App
03-10
Winform中DataDridView的简单使用，对列表的删改/移动。详细内容见https://www.cnblogs.com/hubEnergy/p/10486333.html
C# Winform DataGridView添加数据
weixin_41924879的博客
03-10 5223
C# Winform DataGridView添加数据 private void btnAddData_Click(object sender, EventArgs e) { int i = this.BatchManagement.Rows.Add(); this.BatchManagement.Rows[i].Cells[0].Value = i+1;...
Winform中向DataGridView控件添加数据
zjisme的专栏
11-16 2875
 在Winform中向DataGridView控件添加数据很常用到，现总结3种填充DataGridView方法：1.利用SqlDataAdapter对象向DataGridView中添加数据关键代码：（可以将该代码放到窗体加载事件的方法中）using (SqlDataAdapter da = new SqlDataAdapter("select * from Prod
ea插件开发笔记
lfl_web_foreEnd的博客
06-06 475
在上面的代码中，我们首先通过 winax 库创建了一个 COM 对象 ea，然后使用 ea.Repository 属性获取了 EA 的 Repository 对象，通过 OpenFile 方法打开了一个模型文件，然后使用 GetElementSet 方法获取了所有的元素，最后循环遍历每个元素并输出其名称。// 打开模型 ea.Repository.OpenFile('C:\\path\\to\\your\\model.eap');# 创建EA对象实例。// 释放COM对象。
【开发工具】使用Enterprise Architect(EA)的插件AtScope，解析代码中函数和变量调用关系
qq_43598101的博客
09-11 299
EA和AtScope都安装好并license通过后，可以在EA的扩张中找到AtScope插件。AtScope是EA的插件，可以用来分析代码结构，查看工程中的文件之间的变量和函数调用关系。Enterprise Architect简称EA，是用来设计程序流程图和结构图的软件。双击图中的线就能获得函数和变量的调用关系，注意有的实线是两个虚线重合了。在At中选择要解析的工程，下面选择コンポーネント構造図。必须先打开一个EA项目才能打开At，不然无法打开。再到解析设定中勾选变量包含选项。这里以EA10版本为例。
winform异步加载数据到界面
weixin_30916125的博客
09-29 533
做一个学习记录。 有两个需求： 1.点击按钮，异步加载数据，不卡顿UI。 2.把获取的数据加载到gridview上面。 对于需求1，2，代码如下： 　　　　 public delegate void ShowDatatableDelegate(DataTable dt); 　　　　private async void button1_Click(object...
C# winfrom DataGridView 全选
07-16
在C# WinForm开发中，`DataGridView`是一个常用的控件，用于显示数据表格。它提供了丰富的功能，包括数据编辑、排序、筛选等。本篇将深入探讨如何实现`DataGridView`的全选功能。 首先，全选功能在用户界面中通常...
Winfrom 分页DataGridView 1.0
09-06
这是一个winfrom 通用的增删该查加分页 用户控件，具体使用方法加QQ786198495
Winfrom DataGridView多表头
12-21
在Windows Forms应用开发中，`DataGridView`控件是用于显示数据网格的重要组件，它支持多种功能，如排序、筛选、编辑等。当涉及到更复杂的表格布局时，例如需要展示多个层次的表头，这时就可以利用`Winfrom ...
DataGridView 控件显示树结构
09-24
开发工具：Vs2012 语言c# winform 源码可以调试，运行。在DataGridView中显示树形结构。
winform dataGridView插件实现增删改查
08-17
dataGridView用来展示数据非常实用的控件，也介绍有对工具栏menuStrip的用法
mt4一键交易EA插件
07-23
一键交易EA是MetaTrader4的扩展的功能。可以让交易员更快速的执行买/卖订单，外汇交易只需一次点击！ 这个EA可以为您为您提供： 一键创建买/卖订单 一键平仓所有的头寸 – 包括对冲 查看你的利润和亏损的点数 设置止损和止赢点数
Winform DataGridView中利用WebClient异步加载显示网络地址的图片
05-17
Winform中的DataGridView，支持显示图片的一种列类型(Column Type)，叫 DataGridViewImageColumn ，显示图片就是用这种列，但是这种列不支持网络地址，要显示网络上的图片，必须下载到本地，由于一个datagridview中显示的数据量可能比较大，如果每行的图片都是同步显示，则程序会长时间的BLOCK住，UE会很差，所以需要采用异步加载的方式。
c#datagrid操作，解决datagridView加载慢.docx
06-23
发现了datagridview直接绑定DataSource加载数据比较慢的问题，从网上找了很多资料，没有有效的解决方案，
Winfrom DataGridView中使用进度条.rar
04-29
在C# Winform开发中，`DataGridView`是一个非常常用的控件，用于展示表格数据。而将进度条（ProgressBar）集成到`DataGridView`中，可以提供更直观的数据展示方式，尤其适用于那些需要显示处理进度或者任务状态的...
Sparx Systems资深开发谈EA新特性以及插件开发-UMLChina讲座
rolt的专栏
10-20 400
时间 北京时间 2020年11月6日（周五）19:00-20:00（暂定） 地点 通过腾讯会议举行，会议号：681 774 2045。腾讯会议客户端下载>> 费用 不收费 专家 Miles Ma，Sparx Systems公司资深开发工程师。 语言 中文 内容简介 Enterprise Architect新特性 Enterprise Architect的未来 Enterprise Architect的文档功能 Enterprise Architect的插件开发
winfrom datagridview1 加单选框
最新发布
11-06
1. 在 DataGridView 控件中，找到要添加单选框的列，可以是新的列，也可以是现有的列。假设现有的列为 dataGridView1 中的某一列。 2. 为 DataGridView 控件中的每一行添加一个 DataGridViewRadioButtonCell 单元格...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值