null - 程序员宅基地

排序类.不管什么类型都能排-程序员宅基地

代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel;
using System.Reflection;
using System.Collections;

namespace WebAuditBLL.Core
{
     public class SortedBindingList < T > : IList < T > , IBindingList, IEnumerable < T > , ICancelAddNew
    {
         #region 字段与属性

         // 源列表IList
         private IList < T > m_lsList;

         // 源列表IBindingList
         private IBindingList m_lsBindingList;

         // 是否已排了序
         private bool m_bSorted;

         // 是否提供可邦定源
         private bool m_bSupportsBinding;

         private bool m_bInitiatedLocally;

         // 参与属性描述器
         private PropertyDescriptor m_objSortByPro;

         // 不参与排序的属性描述器
         private PropertyDescriptor m_objNotSortPro;

         // 不参与排序的属性描述器等于这些值不参与排序
         private string [] m_aryThisValueNotSort;

         // 不参与排序的属性名
         private string [] m_aryNotSortStr;

         // 排序方向
         private ListSortDirection m_objOrderDirect = ListSortDirection.Ascending;

         // 排序列表
         private List < ListItem > m_lstSortIndex = new List < ListItem > ();

         // 最后一个是否参与排序
         private bool m_bIsSortLast = true ;

         /// <summary>
         /// 项发生变化的事件
         /// </summary>
         public event ListChangedEventHandler ListChanged;

         /// <summary>
         /// 当BIsSortLast为flase时或对某些指定值的行不作排序（即用于构造函数3）才可能发出此事件，这事件作用是用来设置“合计”，“小计”那行的风格
         /// </summary>
         public event ListChangedEventHandler ListChangedForIsSortLast;

         /// <summary>
         /// 原数据源
         /// </summary>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
         public IList < T > SourceList
        {
             get
            {
                 return m_lsList;
            }
        }

         /// <summary>
         /// 是否已排了序
         /// </summary>
         public bool IsSorted
        {
             get
            {
                 return m_bSorted;
            }
        }

         /// <summary>
         /// 最后一个是否参与排序
         /// </summary>
         public bool BIsSortLast
        {
             get { return m_bIsSortLast; }

             set { m_bIsSortLast = value; }
        }

         #endregion

         /// <summary>
         /// 构造函数1
         /// </summary>
         /// <param name="list"></param>
         public SortedBindingList(IList < T > lsList)
        {
            m_lsList = lsList;

             if (m_lsList is IBindingList)
            {
                m_bSupportsBinding = true ;

                m_lsBindingList = (IBindingList)m_lsList;

                m_lsBindingList.ListChanged += new ListChangedEventHandler(SourceChanged);
            }
        }

         /// <summary>
         /// 构造函数2
         /// </summary>
         /// <param name="lsList"></param>
         /// <param name="bF"> 该参数的插入只是为了区分构造函数3，可为任意值 </param>
         /// <param name="aryNotSortStr"> 不参与排序的属性名列表 </param>
         public SortedBindingList(IList < T > lsList, bool bF, params string [] aryNotSortStr)
        {
            m_lsList = lsList;

             if (m_lsList is IBindingList)
            {
                m_bSupportsBinding = true ;

                m_lsBindingList = (IBindingList)m_lsList;

                m_lsBindingList.ListChanged += new ListChangedEventHandler(SourceChanged);
            }

             if (aryNotSortStr != null )
                m_aryNotSortStr = aryNotSortStr;
        }

         /// <summary>
         /// 构造函数3，第二个参数是属性名且属性类型是string
         /// </summary>
         /// <param name="lsList"> 数据源 </param>
         /// <param name="sPropertyName"> 指定不参与排序的属性名且属性类型只能是string，不支持其它类型 </param>
         /// <param name="aryThisValueNotSort"> 第二个参数属性等于这些值时不参与排序 </param>
         public SortedBindingList(IList < T > lsList, string sPropertyName, params string [] aryThisValueNotSort)
        {
            m_lsList = lsList;

             if (m_lsList is IBindingList)
            {
                m_bSupportsBinding = true ;

                m_lsBindingList = (IBindingList)m_lsList;

                m_lsBindingList.ListChanged += new ListChangedEventHandler(SourceChanged);
            }

            m_objNotSortPro = null ;

             if ( ! String.IsNullOrEmpty(sPropertyName))
            {
                Type itemType = typeof (T);

                 foreach (PropertyDescriptor it in TypeDescriptor.GetProperties(itemType))
                {
                     if (it.Name == sPropertyName)
                    {
                        m_objNotSortPro = it;

                         break ;
                    }
                }
            }

             if (aryThisValueNotSort != null )
                m_aryThisValueNotSort = aryThisValueNotSort;
        }

         /// <summary>
         /// 列表更改或列表中的项更改时发生时处理函数
         /// </summary>
         /// <param name="sender"></param>
         /// <param name="e"></param>
         private void SourceChanged( object sender, ListChangedEventArgs e)
        {
             if (m_bSorted)
            {
                 switch (e.ListChangedType)
                {
                     case ListChangedType.ItemAdded:

                        T newItem = m_lsList[e.NewIndex];

                         if (e.NewIndex == m_lsList.Count - 1 )
                        {
                             object newKey;

                             if (m_objSortByPro != null )
                                newKey = m_objSortByPro.GetValue(newItem);
                             else
                                newKey = newItem;

                             if (m_objOrderDirect == ListSortDirection.Ascending)
                                m_lstSortIndex.Add( new ListItem(newKey, e.NewIndex));
                             else
                                m_lstSortIndex.Insert( 0 , new ListItem(newKey, e.NewIndex));

                             if ( ! m_bInitiatedLocally)
                                OnListChanged( new ListChangedEventArgs(ListChangedType.ItemAdded, SortedIndex(e.NewIndex)));
                        }
                         else
                            DoSort();

                             break ;

                     case ListChangedType.ItemChanged:

                        OnListChanged( new ListChangedEventArgs(ListChangedType.ItemChanged, SortedIndex(e.NewIndex), e.PropertyDescriptor));

                         break ;

                     case ListChangedType.ItemDeleted:

                         if ( ! m_bInitiatedLocally)
                            DoSort();

                         break ;

                     default :
                         if ( ! m_bInitiatedLocally)
                            DoSort();

                         break ;
                }
            }
             else
                OnListChanged(e);
        }

         #region IBindingList, IList<T> 成员

         /// <summary>
         /// 对列有进行排序
         /// </summary>
         /// <param name="sPropertyName"></param>
         /// <param name="objDirection"></param>
         public void ApplySort( string sPropertyName, ListSortDirection objDirection)
        {
            m_objSortByPro = null ;

             if ( ! String.IsNullOrEmpty(sPropertyName))
            {
                Type itemType = typeof (T);

                 foreach (PropertyDescriptor it in TypeDescriptor.GetProperties(itemType))
                {
                     if (it.Name == sPropertyName)
                    {
                        m_objSortByPro = it;

                         break ;
                    }
                }
            }

            ApplySort(m_objSortByPro, objDirection);

        }

         /// <summary>
         /// 对列有进行排序－－实现IBindingList接口
         /// </summary>
         /// <param name="objProperty"></param>
         /// <param name="objDirection"></param>
         public void ApplySort(PropertyDescriptor objProperty, ListSortDirection objDirection)
        {
             if (m_aryNotSortStr != null )
                 foreach ( string it in m_aryNotSortStr)
                     if (objProperty.Name == it)
                         return ;

            m_objSortByPro = objProperty;

            m_objOrderDirect = objDirection;

             // ===================================
             if (m_objNotSortPro != null && (m_aryThisValueNotSort != null || m_aryThisValueNotSort.Length > 0 ))
            {
                List < T > lsTemp = new List < T > ();

                var pExcept = from i in m_lsList where m_aryThisValueNotSort.Contains(m_objNotSortPro.GetValue(i).ToString()) select i;

                lsTemp = pExcept.Cast < T > ().ToList();

                 for ( int i = 0 ; i < lsTemp.Count; i ++ )
                    m_lsList.RemoveAt(m_lsList.Count - 1 );

                DoSort();

                 foreach (T obj in lsTemp)
                    m_lsList.Add(obj);

                 // Dictionary<int, T> dicTemp = new Dictionary<int,T>();

                 // dicTemp.Clear();

                 // int i = 0;

                 // foreach (T obj in m_lsList)
                 // {
                 //     foreach (string it in m_aryThisValueNotSort)
                 //         if (m_objNotSortPro.GetValue(obj).ToString() == it)
                 //         {
                 //             if (!dicTemp.ContainsKey(i))
                 //                 dicTemp.Add(i, obj);

                 //             break;
                 //         }

                 //     i++;
                 // }

                 // List<int> lsInt = dicTemp.Keys.ToList();

                 // lsInt.Sort();

                 // for (int j = 0; j < lsInt.Count; j++)
                 // {
                 //     m_lsList.RemoveAt(lsInt[j] - j);
                 // }

                 // foreach (int nKey in dicTemp.Keys)
                 //     m_lsList.Add(dicTemp[nKey]);

                OnListChangedForIsSortLast( new ListChangedEventArgs(ListChangedType.Reset, 0 ));

                 return ;
            }

             // ============================
             if (m_bIsSortLast)
                DoSort();
             else
            {
                T objT = m_lsList[m_lsList.Count - 1 ];

                m_lsList.RemoveAt(m_lsList.Count - 1 );

                DoSort();

                m_lsList.Add(objT);
            }

             if (m_bIsSortLast == false )
                OnListChangedForIsSortLast( new ListChangedEventArgs(ListChangedType.Reset, 0 ));

        }

         /// <summary>
         /// 返回具有给定 System.ComponentModel.PropertyDescriptor 的行的索引
         /// </summary>
         /// <param name="sPropertyName"></param>
         /// <param name="key"></param>
         /// <returns></returns>
         public int Find( string sPropertyName, object key)
        {
            PropertyDescriptor objFindProperty = null ;

             if ( ! String.IsNullOrEmpty(sPropertyName))
            {
                Type itemType = typeof (T);

                 foreach (PropertyDescriptor prop in TypeDescriptor.GetProperties(itemType))
                {
                     if (prop.Name == sPropertyName)
                    {
                        objFindProperty = prop;

                         break ;
                    }
                }
            }

             return Find(objFindProperty, key);

        }

         /// <summary>
         ///   激发ListChanged事件
         /// </summary>
         /// <param name="e"></param>
         protected void OnListChanged(ListChangedEventArgs e)
        {
             if (ListChanged != null )
                ListChanged( this , e);
        }

         protected void OnListChangedForIsSortLast(ListChangedEventArgs e)
        {
             if (ListChangedForIsSortLast != null )
                ListChangedForIsSortLast( this , e);
        }

         /// <summary>
         /// 返回具有给定 System.ComponentModel.PropertyDescriptor 的行的索引－－实现IBindingList接口
         /// </summary>
         /// <param name="property"></param>
         /// <param name="key"></param>
         /// <returns></returns>
         public int Find(PropertyDescriptor objProperty, object objKey)
        {
             if (m_bSupportsBinding)
                 return SortedIndex(m_lsBindingList.Find(objProperty, objKey));
             else
                 return - 1 ;
        }

         /// <summary>
         /// 撤销排序－－实现IBindingList接口
         /// </summary>
         public void RemoveSort()
        {
            UndoSort();
        }

         /// <summary>
         /// 添加到用于搜索的索引－－实现IBindingList接口
         /// </summary>
         /// <param name="objProperty"></param>
         public void AddIndex(PropertyDescriptor objProperty)
        {
             if (m_bSupportsBinding)
                m_lsBindingList.AddIndex(objProperty);
        }

         /// <summary>
         /// 将新项添加到列表－－实现IBindingList接口
         /// </summary>
         /// <returns></returns>
         public object AddNew()
        {
             object result;

             if (m_bSupportsBinding)
            {
                m_bInitiatedLocally = true ;

                result = m_lsBindingList.AddNew();

                m_bInitiatedLocally = false ;

                OnListChanged( new ListChangedEventArgs(ListChangedType.ItemAdded, m_lsBindingList.Count - 1 ));
            }
             else
                result = null ;

             return result;
        }

         /// <summary>
         /// 获取是否可更新列表中的项－－实现IBindingList接口
         /// </summary>
         public bool AllowEdit
        {
             get
            {
                 if (m_bSupportsBinding)
                     return m_lsBindingList.AllowEdit;
                 else
                     return false ;
            }
        }

         /// <summary>
         /// 获取是否可以使用 System.ComponentModel.IBindingList.AddNew() 向列表中添加项－－实现IBindingList接口
         /// </summary>
         public bool AllowNew
        {
             get
            {
                 if (m_bSupportsBinding)
                     return m_lsBindingList.AllowNew;
                 else
                     return false ;
            }
        }

         /// <summary>
         /// 获取是否可以使用 System.Collections.IList.Remove(System.Object) 或 System.Collections.IList.RemoveAt(System.Int32)
         /// 从列表中移除项。－－实现IBindingList接口
         /// </summary>
         public bool AllowRemove
        {
             get
            {
                 if (m_bSupportsBinding)
                     return m_lsBindingList.AllowRemove;
                 else
                     return false ;
            }
        }

         /// <summary>
         /// 从用于搜索的索引中移除 System.ComponentModel.PropertyDescriptor－－实现IBindingList接口
         /// </summary>
         /// <param name="property"></param>
         public void RemoveIndex(PropertyDescriptor property)
        {
             if (m_bSupportsBinding)
                m_lsBindingList.RemoveIndex(property);
        }

         public ListSortDirection SortDirection
        {
             get
            {
                 return m_objOrderDirect;
            }
        }

         public PropertyDescriptor SortProperty
        {
             get
            {
                 return m_objSortByPro;
            }
        }

         /// <summary>
         /// 获取当列表更改或列表中的项更改时是否引发 System.ComponentModel.IBindingList.ListChanged 事件
         /// </summary>
         public bool SupportsChangeNotification
        {
             get
            {
                 return true ;
            }
        }

         public bool SupportsSearching
        {
             get
            {
                 if (m_bSupportsBinding)
                     return m_lsBindingList.SupportsSearching;
                 else
                     return false ;
            }
        }

         public bool SupportsSorting
        {
             get
            {
                 return true ;
            }
        }

         /// <summary>
         /// 添加项
         /// </summary>
         /// <param name="item"></param>
         public void Add(T item)
        {
            m_lsList.Add(item);
        }

         /// <summary>
         /// 清空所有
         /// </summary>
         public void Clear()
        {
            m_lsList.Clear();
        }

         /// <summary>
         /// 是否含有某项
         /// </summary>
         /// <param name="item"></param>
         /// <returns></returns>
         public bool Contains(T item)
        {
             return m_lsList.Contains(item);
        }

         /// <summary>
         /// 移除某项
         /// </summary>
         /// <param name="item"></param>
         /// <returns></returns>
         public bool Remove(T item)
        {
             return m_lsList.Remove(item);
        }

         /// <summary>
         /// 是否只读
         /// </summary>
         public bool IsReadOnly
        {
             get
            {
                 return m_lsList.IsReadOnly;
            }
        }

         /// <summary>
         /// 取得某项索引
         /// </summary>
         /// <param name="item"></param>
         /// <returns></returns>
         public int IndexOf(T item)
        {
             return SortedIndex(m_lsList.IndexOf(item));
        }

         public void Insert( int index, T item)
        {
            m_lsList.Insert(index, item);
        }

         public T this [ int index]
        {
             get
            {
                 if (m_bSorted)
                     return m_lsList[OriginalIndex(index)];
                 else
                     return m_lsList[index];
            }
             set
            {
                 if (m_bSorted)
                    m_lsList[OriginalIndex(index)] = value;
                 else
                    m_lsList[index] = value;
            }
        }

         int System.Collections.IList.IndexOf( object value)
        {
             return IndexOf((T)value);
        }

         void System.Collections.IList.Insert( int index, object value)
        {
            Insert(index, (T)value);
        }

         /// <summary>
         /// 移除指定索引的项
         /// </summary>
         /// <param name="index"></param>
         public void RemoveAt( int index)
        {
             if (m_bSorted)
            {
                m_bInitiatedLocally = true ;
                 int baseIndex = OriginalIndex(index);

                m_lsList.RemoveAt(baseIndex);

                 if (m_lsList.Count != m_lstSortIndex.Count)
                {
                     if (m_objOrderDirect == ListSortDirection.Ascending)
                        m_lstSortIndex.RemoveAt(index);
                     else
                        m_lstSortIndex.RemoveAt(m_lstSortIndex.Count - 1 - index);

                     foreach (ListItem item in m_lstSortIndex)
                         if (item.BaseIndex > baseIndex)
                            item.BaseIndex -= 1 ;
                }

                OnListChanged( new ListChangedEventArgs(ListChangedType.ItemDeleted, index));
                m_bInitiatedLocally = false ;
            }
             else
                m_lsList.RemoveAt(index);
        }

         int System.Collections.IList.Add( object value)
        {
            Add((T)value);

             return SortedIndex(m_lsList.Count - 1 );
        }

         bool System.Collections.IList.Contains( object value)
        {
             return Contains((T)value);
        }

         bool System.Collections.IList.IsFixedSize
        {
             get
            {
                 return false ;
            }
        }

         object System.Collections.IList. this [ int index]
        {
             get
            {
                 return this [index];
            }
             set
            {
                 this [index] = (T)value;
            }
        }

         void System.Collections.IList.Remove( object value)
        {
            Remove((T)value);
        }

         #endregion

         #region 取得List中的Item的位置

         /// <summary>
         /// 用排序后的位置取得未排序前的位置
         /// </summary>
         /// <param name="nSortedIndex"></param>
         /// <returns></returns>
         private int OriginalIndex( int nSortedIndex)
        {
             if (m_bSorted)
            {
                 if (m_objOrderDirect == ListSortDirection.Ascending)
                     return m_lstSortIndex[nSortedIndex].BaseIndex;
                 else
                     return m_lstSortIndex[m_lstSortIndex.Count - 1 - nSortedIndex].BaseIndex;
            }
             else
                 return nSortedIndex;
        }

         /// <summary>
         /// 用排序前的位置取得排序后的位置
         /// </summary>
         /// <param name="nOriginalIndex"></param>
         /// <returns></returns>
         private int SortedIndex( int nOriginalIndex)
        {
             int result = 0 ;

             if (m_bSorted)
            {
                 for ( int index = 0 ; index < m_lstSortIndex.Count; index ++ )
                {
                     if (m_lstSortIndex[index].BaseIndex == nOriginalIndex)
                    {
                        result = index;

                         break ;
                    }
                }

                 if (m_objOrderDirect == ListSortDirection.Descending)
                    result = m_lstSortIndex.Count - 1 - result;
            }
             else
                result = nOriginalIndex;

             return result;

        }

         #endregion

         #region 排序/撤销排序

         /// <summary>
         /// 排序
         /// </summary>
         private void DoSort()
        {
             int index = 0 ;

            m_lstSortIndex.Clear();

             if (m_objSortByPro == null )
            {
                 foreach (T obj in m_lsList)
                {
                    m_lstSortIndex.Add( new ListItem(obj, index));

                    index ++ ;
                }
            }
             else
            {
                 foreach (T obj in m_lsList)
                {
                    m_lstSortIndex.Add( new ListItem(m_objSortByPro.GetValue(obj), index));

                    index ++ ;
                }
            }

            m_lstSortIndex.Sort();

            m_bSorted = true ;

            OnListChanged( new ListChangedEventArgs(ListChangedType.Reset, 0 ));

        }

         /// <summary>
         /// 撤销排序
         /// </summary>
         private void UndoSort()
        {
            m_lstSortIndex.Clear();

            m_objSortByPro = null ;

            m_objOrderDirect = ListSortDirection.Ascending;

            m_bSorted = false ;

            OnListChanged( new ListChangedEventArgs(ListChangedType.Reset, 0 ));

        }

         #endregion

         #region IEnumerable与IEnumerable<T> 成员

        IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
             return GetEnumerator();
        }

         public IEnumerator < T > GetEnumerator()
        {
             if (m_bSorted)
                 return new SortedEnumerator(m_lsList, m_lstSortIndex, m_objOrderDirect);
             else
                 return m_lsList.GetEnumerator();
        }

         #endregion

         #region ICollection与ICollection<T> 成员

         public int Count
        {
             get
            {
                 return m_lsList.Count;
            }
        }

         bool System.Collections.ICollection.IsSynchronized
        {
             get
            {
                 return false ;
            }
        }

         object System.Collections.ICollection.SyncRoot
        {
             get
            {
                 return m_lsList;
            }
        }

         public void CopyTo(T[] array, int arrayIndex)
        {
            m_lsList.CopyTo(array, arrayIndex);
        }

         void System.Collections.ICollection.CopyTo(System.Array array, int index)
        {
            CopyTo((T[])array, index);
        }

         #endregion

         #region ICancelAddNew 成员

         void ICancelAddNew.CancelNew( int itemIndex)
        {
            ICancelAddNew can = m_lsList as ICancelAddNew;
             if (can != null )
                can.CancelNew(itemIndex);
             else
                m_lsList.RemoveAt(itemIndex);
        }

         void ICancelAddNew.EndNew( int itemIndex)
        {
            ICancelAddNew can = m_lsList as ICancelAddNew;
             if (can != null )
                can.EndNew(itemIndex);
        }

         #endregion

         #region SortedEnumerator 类

         private class SortedEnumerator : IEnumerator < T >
        {
             private IList < T > m_list;

             private List < ListItem > m_sortIndex;

             private ListSortDirection m_sortOrder;

             private int m_nIndex;

             private bool _disposedValue = false ;

             public SortedEnumerator(IList < T > list, List < ListItem > sortIndex, ListSortDirection direction)
            {
                m_list = list;

                m_sortIndex = sortIndex;

                m_sortOrder = direction;

                Reset();
            }

             public T Current
            {
                 get
                {
                     return m_list[m_sortIndex[m_nIndex].BaseIndex];
                }
            }

            Object System.Collections.IEnumerator.Current
            {
                 get
                {
                     return m_list[m_sortIndex[m_nIndex].BaseIndex];
                }
            }

             public bool MoveNext()
            {
                 if (m_sortOrder == ListSortDirection.Ascending)
                {
                     if (m_nIndex < m_sortIndex.Count - 1 )
                    {
                        m_nIndex ++ ;
                         return true ;
                    }
                     else
                         return false ;
                }
                 else
                {
                     if (m_nIndex > 0 )
                    {
                        m_nIndex -- ;
                         return true ;
                    }
                     else
                         return false ;
                }
            }

             public void Reset()
            {
                 if (m_sortOrder == ListSortDirection.Ascending)
                    m_nIndex = - 1 ;
                 else
                    m_nIndex = m_sortIndex.Count;
            }

             #region IDisposable 实现

             protected virtual void Dispose( bool disposing)
            {
                 if ( ! _disposedValue)
                {
                     if (disposing)
                    {
                    }
                }
                _disposedValue = true ;
            }

             public void Dispose()
            {
                Dispose( true );
                GC.SuppressFinalize( this );
            }

             ~ SortedEnumerator()
            {
                Dispose( false );
            }

             #endregion

        }

         #endregion

         #region ListItem 类

         private class ListItem : IComparable < ListItem >
        {
             private object m_objKey;

             private int m_nBaseIndex;

             public object Key
            {
                 get
                {
                     return m_objKey;
                }
            }

             public int BaseIndex
            {
                 get
                {
                     return m_nBaseIndex;
                }
                 set
                {
                    m_nBaseIndex = value;
                }
            }

             public   ListItem( object objKey, int nBaseIndex)
            {
                m_objKey = objKey;

                m_nBaseIndex = nBaseIndex;
            }

             // 实现IComparable接口
             public int CompareTo(ListItem other)
            {
                 object target = other.Key;

                 if (Key is IComparable)
                     return ((IComparable)Key).CompareTo(target);

                 else
                {
                     if (Key == null )
                    {
                         if (target == null )
                             return 0 ;
                         else
                             return - 1 ;
                    }
                     else if (Key.Equals(target))
                         return 0 ;
                     else
                         return Key.ToString().CompareTo(target.ToString());
                }
            }

             public override string ToString()
            {
                 return Key.ToString();
            }

        }

         #endregion
    }
}

使用 SortedBindingList<CashInCome> m_lsSort = new SortedBindingList<CashInCome>(dtBind);

转载于:https://www.cnblogs.com/z2002m/archive/2010/02/23/1671978.html

本文链接：https://blog.csdn.net/weixin_34209851/article/details/92969512

原作者删帖不实内容删帖广告或垃圾文章投诉

智能推荐

React学习记录-程序员宅基地

文章浏览阅读936次，点赞22次，收藏26次。React核心基础

Linux查磁盘大小命令,linux系统查看磁盘空间的命令是什么-程序员宅基地

文章浏览阅读2k次。linux系统查看磁盘空间的命令是【df -hl】，该命令可以查看磁盘剩余空间大小。如果要查看每个根路径的分区大小，可以使用【df -h】命令。df命令以磁盘分区为单位查看文件系统。本文操作环境：red hat enterprise linux 6.1系统、thinkpad t480电脑。(学习视频分享：linux视频教程)Linux 查看磁盘空间可以使用 df 和 du 命令。df命令df 以磁..._df -hl

Office & delphi_range[char(96 + acolumn) + inttostr(65536)].end[xl-程序员宅基地

文章浏览阅读923次。uses ComObj;var ExcelApp: OleVariant;implementationprocedure TForm1.Button1Click(Sender: TObject);const // SheetType xlChart = -4109; xlWorksheet = -4167; // WBATemplate xlWBATWorksheet = -4167_range[char(96 + acolumn) + inttostr(65536)].end[xlup]

若依 quartz 定时任务中 service mapper无法注入解决办法_ruoyi-quartz无法引入ruoyi-admin的service-程序员宅基地

文章浏览阅读2.3k次。上图为任务代码，在任务具体执行的方法中使用，一定要写在方法内使用SpringContextUtil.getBean()方法实例化Spring service类下边是ruoyi-quartz模块中util/SpringContextUtil.java(已改写)import org.springframework.beans.BeansException;import org.springframework.context.ApplicationContext;import org.s..._ruoyi-quartz无法引入ruoyi-admin的service

CentOS7配置yum源-程序员宅基地

文章浏览阅读2w次，点赞10次，收藏77次。yum，全称“Yellow dog Updater, Modified”，是一个专门为了解决包的依赖关系而存在的软件包管理器。可以这么说，yum 是改进型的 RPM 软件管理器，它很好的解决了 RPM 所面临的软件包依赖问题。yum 在服务器端存有所有的 RPM 包，并将各个包之间的依赖关系记录在文件中，当管理员使用 yum 安装 RPM 包时，yum 会先从服务器端下载包的依赖性文件，通过分析此文件从服务器端一次性下载所有相关的 RPM 包并进行安装。_centos7配置yum源

智能科学毕设分享(算法) 基于深度学习的抽烟行为检测算法实现(源码分享)-程序员宅基地

文章浏览阅读828次，点赞21次，收藏8次。今天学长向大家分享一个毕业设计项目毕业设计基于深度学习的抽烟行为检测算法实现(源码分享)毕业设计深度学习的抽烟行为检测算法实现通过目前应用比较广泛的 Web 开发平台，将模型训练完成的算法模型部署，部署于 Web 平台。并且利用目前流行的前后端技术在该平台进行整合实现运营车辆驾驶员吸烟行为检测系统，方便用户使用。本系统是一种运营车辆驾驶员吸烟行为检测系统，为了降低误检率，对驾驶员视频中的吸烟烟雾和香烟目标分别进行检测，若同时检测到则判定该驾驶员存在吸烟行为。进行流程化处理，以满足用户的需要。

随便推点

STM32单片机示例：多个定时器同步触发启动_stm32 定时器同步-程序员宅基地

文章浏览阅读3.7k次，点赞3次，收藏14次。多个定时器同步触发启动是一种比较实用的功能，这里将对此做个示例说明。_stm32 定时器同步

android launcher分析和修改10,Android Launcher分析和修改9——Launcher启动APP流程（转载）...-程序员宅基地

文章浏览阅读348次。出处 : http://www.cnblogs.com/mythou/p/3187881.html本来想分析AppsCustomizePagedView类，不过今天突然接到一个临时任务。客户反馈说机器界面的图标很难点击启动程序，经常点击了没有反应，Boss说要优先解决这问题。没办法，只能看看是怎么回事。今天分析一下Launcher启动APP的过程。从用户点击到程序启动的流程，下面针对WorkSpa..._回调bubbletextview

Ubuntu 12 最快的两个源个人感觉 163与cn99最快 ubuntu安装源下包过慢_un.12.cc-程序员宅基地

文章浏览阅读6.2k次。Ubuntu 12 最快的两个源个人感觉 163与cn99最快 ubuntu下包过慢 1、首先备份Ubuntu 12.04源列表 sudo cp /etc/apt/sources.list /etc/apt/sources.list.backup （备份下当前的源列表，有备无患嘛） 2、修改更新源 sudo gedit /etc/apt/sources.list （打开Ubuntu 12_un.12.cc

vue动态路由（权限设置）_vue动态路由权限-程序员宅基地

文章浏览阅读5.8k次，点赞6次，收藏86次。1.思路（1）动态添加路由肯定用的是addRouter，在哪用？（2）vuex当中获取到菜单，怎样展示到界面2.不管其他先试一下addRouter找到router/index.js文件，内容如下，这是我自己先配置的登录路由现在先不管请求到的菜单是什么样，先写一个固定的菜单通过addRouter添加添加以前注意：addRoutes()添加的是数组在export defult router的上一行图中17行写下以下代码var addRoute=[ { path:"/", name:"_vue动态路由权限

JSTL 之变量赋值标签-程序员宅基地

文章浏览阅读8.9k次。关键词： JSTL 之变量赋值标签 /* * Author Yachun Miao * Created 11-Dec-06 */关于JSP核心库的set标签赋值变量，有两种方式: 1.日期" />2. 有种需求要把ApplicationResources_zh_CN.prope

VGA带音频转HDMI转换芯片|VGA转HDMI 转换器方案|VGA转HDMI1.4转换器芯片介绍_vga转hdmi带音频转换器,转接头拆解-程序员宅基地

文章浏览阅读3.1k次，点赞3次，收藏2次。1.1ZY5621概述ZY5621是VGA音频到HDMI转换器芯片，它符合HDMI1.4 DV1.0规范。ZY5621也是一款先进的高速转换器，集成了MCU和VGA EDID芯片。它还包含VGA输入指示和仅音频到HDMI功能。进一步降低系统制造成本，简化系统板上的布线。ZY5621方案设计简单，且可以完美还原输入端口的信号，此方案设计广泛应用于投影仪、教育多媒体、视频会议、视频展台、工业级主板显示、手持便携设备、转换盒、转换线材等产品设计上面。1.2 ZY5621 特性内置MCU嵌入式VGA_vga转hdmi带音频转换器,转接头拆解