2012年10月31日水曜日

DataGridViewとEntityその2

いくつか間抜けな事をしでかしていたので、ざっくり修正。

属性クラス

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace EntitySortSample
{
    /// <summary>
    /// ソート用のEntityに追加するプロパティです。
    /// 単一プロパティによるソートを行った場合、同値だった場合に指定する別プロパティのソートKeyを定義します。
    /// </summary>
    [AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
    public class SortAttribute : Attribute
    {
        /// <summary>
        /// ソート対象となるプロパティの格納を行っているフィールド
        /// </summary>
        private List<string> _properties;
 
        /// <summary>
        /// ソート対象のプロパティを取得します。
        /// </summary>
        public List<string> Properties { get { return this._properties; } }
 
        /// <summary>
        /// コンストラクタ
        /// </summary>
        /// <param name="properties">比較に仕様する追加プロパティ名</param>
        public SortAttribute(string[] properties)
        {
            this._properties = properties.ToList<string>();
        }
    }
}



ソート方法を実装したIComparer<T>の実装
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Reflection;
using System.Text;
 
namespace EntitySortSample
{
    /// <summary>
    /// IComparer<T>の実装です。
    /// なお、ソート処理対象のプロパティに配列が使用されているような場合は正常に動作しません。
    /// インデクサも同様です。
    /// もっとも、プロパティに配列を使うなという事を一言記載。
    ///
    /// また、プロパティに指定する型は、必ずIComparableの実装が必要となります。
    /// これは、プロパティの値を比較する際に、ジェネリックメソッドにより、ComparableToにて大小比較を行っている為です。
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class ComparerEx<T> : IComparer<T>
    {
        /// <summary>
        /// ソート対象のプロパティ名
        /// </summary>
        private PropertyDescriptor _propertyDescriptor;
 
        /// <summary>
        /// ソート対象をソートする際のソート方向
        /// </summary>
        private ListSortDirection _listSortDirection;
 
        /// <summary>
        /// コンストラクタ
        /// </summary>
        /// <param name="propertyDescriptor">ソート対象のプロパティ</param>
        /// <param name="listSortDirecton">ソート方向</param>
        public ComparerEx(PropertyDescriptor propertyDescriptor, ListSortDirection listSortDirection)
        {
            this._propertyDescriptor = propertyDescriptor;
            this._listSortDirection = listSortDirection;
        }
 
        /// <summary>
        /// ソート処理で必要な大小比較を行い、処理結果により
        /// マイナス値~プラス値までを戻します。
        /// 完全な同一値の場合は0を返します。
        /// </summary>
        /// <param name="x">比較対象のオブジェクト1です。</param>
        /// <param name="y">比較対象のオブジェクト2です。</param>
        /// <returns>
        /// (昇順ソートの場合。降順は逆になります。)
        /// xがyより小さい場合は、0未満を返します。
        /// xとyが同一の値の場合は0を戻します。
        /// xがyより大きい場合は、0より大きい値を返します。
        /// </returns>
        public int Compare(T x, T y)
        {
            var xPropertyInfo = this.GetPropertyInfo(x, this._propertyDescriptor.Name);
            var yPropertyInfo = this.GetPropertyInfo(y, this._propertyDescriptor.Name);
 
            var xValue = xPropertyInfo.GetValue(x, null);
            var yValue = yPropertyInfo.GetValue(y, null);
 
            var comparableRet = this.Comparable((IComparable)xValue, (IComparable)yValue);
 
            if (comparableRet != 0)
                return comparableRet;
 
            // 同値の場合、PropertyInfoの属性に追加ソート指定項目が存在するかを確認する。
            var xAttributes = xPropertyInfo.GetCustomAttributes(typeof(SortAttribute), false);
            if (xAttributes == null)
                return comparableRet;
 
            // 属性が存在する場合、内部にSortAttributeが定義されているかを確認する。
            foreach (var xAttribute in xAttributes)
            {
                var sortAttribute = xAttribute as SortAttribute;
 
                if (sortAttribute == null)
                    continue;
 
                // SortAttributeの定義が存在する場合は、対象の属性情報に定義されている比較対象の予備プロパティ名を順番に比較していく。
                foreach (var propertyName in sortAttribute.Properties)
                {
                    comparableRet = this.CompareSub(x, y, propertyName);
                    if (comparableRet != 0)
                        return comparableRet;
                }
            }
 
            // ここまで抜けてきた場合は、完全同値の値となる。
            return 0;
        }
 
        /// <summary>
        /// ソート処理で必要な大小比較を行い、処理結果により
        /// マイナス値~プラス値までを戻します。
        /// 完全な同一値の場合は0を返します。
        /// </summary>
        /// <param name="x">比較対象のオブジェクト1です。</param>
        /// <param name="y">比較対象のオブジェクト2です。</param>
        /// <param name="propertyName">比較対象のプロパティです。</param>
        /// <returns>
        /// (昇順ソートの場合。降順は逆になります。)
        /// xがyより小さい場合は、0未満を返します。
        /// xとyが同一の値の場合は0を戻します。
        /// xがyより大きい場合は、0より大きい値を返します。
        /// </returns>
        private int CompareSub(T x, T y, string propertyName)
        {
            var xPropertyInfo = this.GetPropertyInfo(x, propertyName);
            var yPropertyInfo = this.GetPropertyInfo(y, propertyName);
 
            var xValue = xPropertyInfo.GetValue(x, null);
            var yValue = yPropertyInfo.GetValue(y, null);
 
            return this.Comparable((IComparable)xValue, (IComparable)yValue);
        }
 
        /// <summary>
        /// 指定された型に格納されているPropertyInfoの取得を行います。
        /// </summary>
        /// <param name="target">プロパティの情報を取得する対象</param>
        /// <param name="propertyName">取得対象のプロパティ名</param>
        /// <returns></returns>
        private PropertyInfo GetPropertyInfo(T target, string propertyName)
        {
            var propertyInfo = target.GetType().GetProperty(propertyName);
            if (propertyInfo == null)
                throw new ArgumentException(@"指定されてプロパティ名の取得が行えませんでした。");
 
            return propertyInfo;
        }
 
        /// <summary>
        /// 大小比較用のジェネリックメソッドです。
        /// </summary>
        /// <typeparam name="T">比較する型</typeparam>
        /// <param name="x">比較対象の値1</param>
        /// <param name="y">比較対象の値2</param>
        /// <returns>
        /// (昇順ソートの場合。降順は逆になります。)
        /// xがyより小さい場合は、0未満を返します。
        /// xとyが同一の値の場合は0を戻します。
        /// xがyより大きい場合は、0より大きい値を返します。
        /// </returns>
        private int Comparable<T2>(T2 x, T2 y) where T2 : IComparable
        {
            var buf = x.CompareTo(y);
 
            if (this._listSortDirection == ListSortDirection.Ascending)
                return buf;
 
            return buf * -1;
        }
    }
}



最後にBindingListの拡張

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
 
namespace EntitySortSample
{
    /// <summary>
    /// BindingListの拡張クラスです。
    /// </summary>
    /// <typeparam name="T">タイプ</typeparam>
    public class BindingListEx<T> : BindingList<T>
    {
        /// <summary>
        /// ソート項目
        /// </summary>
        private PropertyDescriptor _propertyDescriptor;
 
        /// <summary>
        /// ソート方向(昇順・降順)の保持を行います。
        /// </summary>
        private ListSortDirection _listSortDirection;
 
        /// <summary>
        /// ソート済みかを示す値
        /// </summary>
        private bool _isSortedCore = false;
 
        /// <summary>
        /// ソートのサポートを行う事を宣言
        /// </summary>
        protected override bool SupportsSortingCore
        {
            get
            {
                return true;
            }
        }
 
        /// <summary>
        /// リストのソート順
        /// </summary>
        protected override ListSortDirection SortDirectionCore
        {
            get
            {
                return this._listSortDirection;
            }
        }
 
        /// <summary>
        /// ソート対象
        /// </summary>
        protected override PropertyDescriptor SortPropertyCore
        {
            get
            {
                return this._propertyDescriptor;
            }
        }
 
        /// <summary>
        /// ソート済みかを示す値の取得用
        /// </summary>
        protected override bool IsSortedCore
        {
            get
            {
                return this._isSortedCore;
            }
        }
 
        /// <summary>
        /// コンストラクタ
        /// </summary>
        public BindingListEx()
            : base()
        {
        }
 
        /// <summary>
        /// コンストラクタ
        /// </summary>
        /// <param name="list"></param>
        public BindingListEx(IList<T> list)
            : base(list)
        {
        }
 
        /// <summary>
        /// ソート処理
        /// </summary>
        /// <param name="prop">ソート項目</param>
        /// <param name="direction">ソート方向</param>
        protected override void ApplySortCore(PropertyDescriptor prop, ListSortDirection direction)
        {
            // ソート方向とソートプロパティを格納
            this._propertyDescriptor = prop;
            this._listSortDirection = direction;
 
            // Itemsの存在が無い場合は、処理必要な処理のみ実行して処理を戻します。
            if (base.Items == null || base.Items.Count == 0)
            {
                this._isSortedCore = false;
                base.OnListChanged(new ListChangedEventArgs(ListChangedType.ItemMoved, prop));
 
                return;
            }
 
            // Itemsが存在する場合はComparerExを生成して、比較処理を実行します。
            var items = (List<T>)base.Items;
            var comparerEx = new ComparerEx<T>(this._propertyDescriptor, this._listSortDirection);
            items.Sort(comparerEx);
 
            // ソート処理の終了を設定
            this._isSortedCore = true;
            base.OnListChanged(new ListChangedEventArgs(ListChangedType.ItemMoved, prop));
 
            return;
        }
    }
} 

2012年10月25日木曜日

DataGridViewとEntity

毎度毎度EntityをDataGridにぶち込んだ際に、ソート処理を実装するので、ある程度のサンプルをこちらに記載。

自分用の備忘録で、未テストの適当コードなので注意。

あとでテスト済みをソリューション毎乗っけるかもしれない?

BindingListの拡張

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
 
namespace EntityFrameworkSample
{
    /// <summary>
    /// BindingListの拡張クラスです。
    /// </summary>
    /// <typeparam name="T">タイプ</typeparam>
    public class BindingListEx<T> : BindingList<T>
    {
        /// <summary>
        /// ソート項目
        /// </summary>
        private PropertyDescriptor _propertyDescriptor;
 
        /// <summary>
        /// ソート方向(昇順・降順)の保持を行います。
        /// </summary>
        private ListSortDirection _listSortDirection;
 
        /// <summary>
        /// ソート済みかを示す値
        /// </summary>
        private bool _isSortedCore = false;
 
        /// <summary>
        /// ソートのサポートを行う事を宣言
        /// </summary>
        protected override bool SupportsSortingCore
        {
            get
            {
                return true;
            }
        }
 
        /// <summary>
        /// リストのソート順
        /// </summary>
        protected override ListSortDirection SortDirectionCore
        {
            get
            {
                return this._listSortDirection;
            }
        }
 
        /// <summary>
        /// ソート対象
        /// </summary>
        protected override PropertyDescriptor SortPropertyCore
        {
            get
            {
                return this._propertyDescriptor;
            }
        }
 
        /// <summary>
        /// ソート済みかを示す値の取得用
        /// </summary>
        protected override bool IsSortedCore
        {
            get
            {
                return this._isSortedCore;
            }
        }
 
        /// <summary>
        /// コンストラクタ
        /// </summary>
        public BindingListEx()
            : base()
        {
        }
 
        /// <summary>
        /// コンストラクタ
        /// </summary>
        /// <param name="list"></param>
        public BindingListEx(IList<T> list)
            : base(list)
        {
        }
 
        /// <summary>
        /// ソート処理
        /// </summary>
        /// <param name="prop">ソート項目</param>
        /// <param name="direction">ソート方向</param>
        protected override void ApplySortCore(PropertyDescriptor prop, ListSortDirection direction)
        {
            // ソート方向とソートプロパティを格納
            this._propertyDescriptor = prop;
            this._listSortDirection = direction;
 
            // Itemsの存在が無い場合は、処理必要な処理のみ実行して処理を戻します。
            if (base.Items == null || base.Items.Count == 0)
            {
                this._isSortedCore = false;
                base.OnListChanged(new ListChangedEventArgs(ListChangedType.ItemMoved, prop));
 
                return;
            }
 
            // Itemsが存在する場合はComparerExを生成して、比較処理を実行します。
            var items = (List<T>)base.Items;
            var comparerEx = new ComparerEx<T>(this._propertyDescriptor, this._listSortDirection);
            items.Sort(comparerEx);
 
            // ソート処理の終了を設定
            this._isSortedCore = true;
            base.OnListChanged(new ListChangedEventArgs(ListChangedType.ItemMoved, prop));
 
            return;
        }
    }
}


IComparerの実装

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Reflection;
using System.Text;
 
namespace EntityFrameworkSample
{
    /// <summary>
    /// IComparer<T>の実装です。
    /// なお、ソート処理対象のプロパティに配列が使用されているような場合は正常に動作しません。
    /// インデクサも同様です。
    /// もっとも、プロパティに配列を使うなという事を一言記載。
    ///
    /// また、プロパティに指定する型は、必ずIComparableの実装が必要となります。
    /// これは、プロパティの値を比較する際に、ジェネリックメソッドにより、ComparableToにて大小比較を行っている為です。
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class ComparerEx<T> : IComparer<T>
    {
        /// <summary>
        /// ソート対象のプロパティ名
        /// </summary>
        private PropertyDescriptor _propertyDescriptor;
 
        /// <summary>
        /// ソート対象をソートする際のソート方向
        /// </summary>
        private ListSortDirection _listSortDirection;
 
        /// <summary>
        /// コンストラクタ
        /// </summary>
        /// <param name="propertyDescriptor">ソート対象のプロパティ</param>
        /// <param name="listSortDirecton">ソート方向</param>
        public ComparerEx(PropertyDescriptor propertyDescriptor, ListSortDirection listSortDirection)
        {
            this._propertyDescriptor = propertyDescriptor;
            this._listSortDirection = listSortDirection;
        }
 
        /// <summary>
        /// ソート処理で必要な大小比較を行い、処理結果により
        /// マイナス値~プラス値までを戻します。
        /// 完全な同一値の場合は0を返します。
        /// </summary>
        /// <param name="x">比較対象のオブジェクト1です。</param>
        /// <param name="y">比較対象のオブジェクト2です。</param>
        /// <returns>
        /// (昇順ソートの場合。降順は逆になります。)
        /// xがyより小さい場合は、0未満を返します。
        /// xとyが同一の値の場合は0を戻します。
        /// xがyより大きい場合は、0より大きい値を返します。
        /// </returns>
        public int Compare(T x, T y)
        {
            var xPropertyInfo = this.GetPropertyInfo(x, this._propertyDescriptor.Name);
            var yPropertyInfo = this.GetPropertyInfo(y, this._propertyDescriptor.Name);
 
            var xValue = xPropertyInfo.GetValue(x, null);
            var yValue = yPropertyInfo.GetValue(y, null);
 
            var comparableRet = this.Comparable((IComparable)xValue, (IComparable)yValue);
 
            if (comparableRet != 0)
                return comparableRet;
 
            // 同値の場合、PropertyInfoの属性に追加ソート指定項目が存在するかを確認する。
            var xAttributes = xPropertyInfo.GetCustomAttributes(typeof(SortAttribute), false);
            if (xAttributes == null)
                return comparableRet;
 
            // 属性が存在する場合、内部にSortAttributeが定義されているかを確認する。
            foreach (var xAttribute in xAttributes)
            {
                var sortAttribute = xAttribute as SortAttribute;
 
                if (sortAttribute == null)
                    continue;
 
                // SortAttributeの定義が存在する場合は、対象の属性情報に定義されている比較対象の予備プロパティ名を順番に比較していく。
                foreach (var propertyName in sortAttribute.Properties)
                {
                    comparableRet = this.CompareSub(x, y, propertyName);
                    if (comparableRet != 0)
                        return comparableRet;
                }
            }
 
            // ここまで抜けてきた場合は、完全同値の値となる。
            return 0;
        }
 
        /// <summary>
        /// ソート処理で必要な大小比較を行い、処理結果により
        /// マイナス値~プラス値までを戻します。
        /// 完全な同一値の場合は0を返します。
        /// </summary>
        /// <param name="x">比較対象のオブジェクト1です。</param>
        /// <param name="y">比較対象のオブジェクト2です。</param>
        /// <param name="propertyName">比較対象のプロパティです。</param>
        /// <returns>
        /// (昇順ソートの場合。降順は逆になります。)
        /// xがyより小さい場合は、0未満を返します。
        /// xとyが同一の値の場合は0を戻します。
        /// xがyより大きい場合は、0より大きい値を返します。
        /// </returns>
        private int CompareSub(T x, T y, string propertyName)
        {
            var xPropertyInfo = this.GetPropertyInfo(x, propertyName);
            var yPropertyInfo = this.GetPropertyInfo(y, propertyName);
 
            var xValue = xPropertyInfo.GetValue(x, null);
            var yValue = yPropertyInfo.GetValue(y, null);
 
            return this.Comparable((IComparable)xValue, (IComparable)yValue);
        }
 
        /// <summary>
        /// 指定された型に格納されているPropertyInfoの取得を行います。
        /// </summary>
        /// <param name="target">プロパティの情報を取得する対象</param>
        /// <param name="propertyName">取得対象のプロパティ名</param>
        /// <returns></returns>
        private PropertyInfo GetPropertyInfo(T target, string propertyName)
        {
            var propertyInfo = target.GetType().GetProperty(propertyName);
            if (propertyInfo == null)
                throw new ArgumentException(@"指定されてプロパティ名の取得が行えませんでした。");
 
            return propertyInfo;
        }
 
        /// <summary>
        /// 大小比較用のジェネリックメソッドです。
        /// </summary>
        /// <typeparam name="T">比較する型</typeparam>
        /// <param name="x">比較対象の値1</param>
        /// <param name="y">比較対象の値2</param>
        /// <returns>
        /// (昇順ソートの場合。降順は逆になります。)
        /// xがyより小さい場合は、0未満を返します。
        /// xとyが同一の値の場合は0を戻します。
        /// xがyより大きい場合は、0より大きい値を返します。
        /// </returns>
        private int Comparable<T>(T x, T y) where T : IComparable
        {
            var buf = x.CompareTo(y);
 
            if (this._listSortDirection == ListSortDirection.Ascending)
                return buf;
 
            return buf * -1;
        }
    }
}


複数プロパティでのソートする際に仕様するカスタム属性の作成

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace EntityFrameworkSample
{
    /// <summary>
    /// ソート用のEntityに追加するプロパティです。
    /// 単一プロパティによるソートを行った場合、同値だった場合に指定する別プロパティのソートKeyを定義します。
    /// </summary>
    [AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
    public class SortAttribute : Attribute
    {
        /// <summary>
        /// ソート対象となるプロパティの格納を行っているフィールド
        /// </summary>
        private List<string> _properties;
 
        /// <summary>
        /// ソート対象のプロパティを取得します。
        /// </summary>
        public List<string> Properties { get { return this._properties; } }
 
        /// <summary>
        /// コンストラクタ
        /// </summary>
        /// <param name="properties">比較に仕様する追加プロパティ名</param>
        public SortAttribute(string[] properties)
        {
            this._properties = properties.ToList<string>();
        }
    }
}

とりあえず、ざっくり記載。
テストした後の修正バージョンを乗っけるかは、要望次第かも?

2012年10月22日月曜日

とりあえず、開発環境を管理しているバカ相手に話すのが無駄だったことが判明

今現在、私のいる開発環境では、.NETをまともに触ったことのない鳥○というバカが管理をしていました。
今回、新規に画面を作るにあたって、バカの作るフレームワークが役に立たない事を懇切丁寧に、プロパに説明したら、なるほど納得、私の言う通りに作って良いというお達しが出ました。

毎回思いますが、相談する相手を間違えると、バカ相手に時間を取られますね。

ちなみに鳥○は、 IDisposeを実装したフレームワークを実装しておきながら、アンマネージリソースの解放をフレームワーク外に作らせたり、DBの項目定義で、いくつかのコード系を有無しか管理しないのに、Stringで管理させたりと、DBの正規化すらまともにできていない馬鹿ですが、それを相手に話してた私もかなり間抜けだったという話ですね。

まともに相手をしてたらだめだったんです。

そもそもJavaの環境がSVNな時点で、間抜けがVSSでソース管理を押した事自体を問題視して、バカ相手に話をしないで、プロパに話を通しておくべきでした。

いやはや、余計な時間を使いました。

毎回思いますが、この手のバカは、開発に加わるな、加わったとしてもフレームワークとかそういった部分の開発を一切行うな。

くそったれが。

2012年10月21日日曜日

土日で終わらなかったってかばたついてやる暇が一部なかったともいう

ってことで、終わらせる予定だった仕事がおわってねぇー
いぇーい・・・orz

日曜日から徹夜です。

最近本当に色々ばたついてるんですよね(´ρ`)

はぁ~

病院行く日程がはやまるかもしれんし、どないなるんやろうか。

・・・ある意味病気だわな(´ρ`)

まぁ~ある意味狙いすぎで、ある意味病気で、ある意味ここまで来ると関心する・・・




最近非常にばたついております

少々、親族が入院する関係上、最近非常にばたついております。

そんな時に腐ったソースを見る事になると、激しくむかつきますが、いい加減どうにかならないものでしょうかね(´ρ`)

あまりに処理が複雑化する関係上、クラス分割をしたいといったら、駄目だとかぬかすし・・・

本気で最近、氏ねと思います。

最近思うのが、最低限のフレームワーク知識が無い人間は、プログラムを組むべきではないと思っております。
そして、知識をないがしろにして、組めると思って要員計画を行うPMは、プログラムの技術レベルを低く見積もりすぎです。
 今の多くの開発現場は、人を集めて人月工数ではかり、バカでも人を集めて作る方がお金が儲かるような仕組みになっているのがそもそもの間違いの気がします。

また、お客さんも、人が沢山集まるからお金がかかると思っている感覚がそもそも間違いだと気が付いてほしいです。

人が少なかろうが、ピーキーな処理であれば、求められる技術レベルは非常に高くなります。

逆に、人が多かろうが、 簡単な処理なら、安いです。
(人海戦術が必要なほどの大きさならまた別でしょうが、この辺は納期次第ですね(´ρ`))

最近考えるのが、プログラムを請け負うのではなく、お客さん側の技術アドバイザーとして仕事をするような立場で仕事をする業界の人間がいてもいいのかも毎回思います。

SIerとは違い、あくまでも完全なお客さん側のアドバイザーとして、社内SEがいない部分に、システム開発を請け負うSIerとは違う立場でSIer側の開発現場やソースの品質に対して口を出すような仕事があってもいいなと本気で思います。

っというか、↑のような仕事がしたいと最近本当に思いますね。

納品されるソースの品質が低すぎて、将来的にメンテナンス工数などが多くかかりそうなら、そういった観点から、お客さん側のSEとして開発にケチつけるような仕事が。

ってか、こういった部分についても納品するSIer側に丸投げするから、お客さん側も品質などわけがわからんのではないかなと思っています。

どっかこんな仕事してるところないかなぁ~っと思うと同時に、こんなことをしてほしいと思う企業さんいないかなぁ~。

もっとも、この手の仕事をする人たちも開発を行うだろうから、力関係でどうとでも意見を封殺されるだろうか、いっそのこと個人レベルのボランティアとか、または完全な有志による技術検討会みたいなグループとして仕事を受けるしかないとは思いますが。

あとは、そういった部分のソースを一部でも技術検討で意見がSIerと割れた場合、お客さんがどちらを信じていいのかわからない場合に公開する仕組みを作るべきだと思いますね。

セキュリティがといいますが、よほど本当に技術的に価値があるもの以外、実際に公開しても構わないと思うんですよね。

仕訳処理が何か店ごとに特殊かといわれればそこまでかわりませんし。
そうすると組んでるソースの品質とかみるならそういった普遍的な処理を公開すれば問題ないのではないかと。

そら新幹線の制御システムの部分公開を行えとかいったら、断ると思いますが、普遍的になる処理であれば問題ない気がします。

それでもいやなら、処理の全体ではなく部分的な公開でも構わないとは思います。

皆さんどう思いますかね?

第三者の技術検討会みたいな、SIerの納品しようとするソースなどに対して、お客さんの立場から品質に対してケチをつけるようなそういった組織は本当にほしいですね私は。

2012年10月11日木曜日

寒くなってきましたね・・・風邪でぶっ倒れました

どうにも風邪でぶったおれて、二日ほどお休みしてました。
(´-`) ンー寒くなってきたな本当に最近。

家の中にいても、夜になると、ちょっくら肌寒いですもんね。

ってことで皆さんも本当に注意を(´ρ`)
 

2012年10月10日水曜日

日付型をいい加減Char(8)とかでもつのをやめてほしい・・・

特に検索にて、日付のみしか持たない項目で、Indexを張って高速に日付の検索を行う目的などが無い限り、日付は日付型で持ってほしいですorz
(↑のもよほどの事が無い限り嫌です。理由は最後に。)

DataGridにぶち込むのに日付型に直してフォーマットかけたり、帳票の出力に合わせて、フォーマットをまたまた変えて表示する際に、文字列だとめんどいです。

SQLから引っ張ってくるときに、Date型に変えれば良いじゃんという意見もありますが、
そもそも取得処理ではデータ加工をしない方が良いと思っているのが私です。

これは、データの取得部分が処理に引っ張られるのは、( ‥) ン?っとなるからです。

必要であれば、使う側が加工して処理をすればいいのです。

そういった意味では、DBに格納するデータは、未加工のそのままの適切な型で格納されているのが個人的には望ましいです。

もっとも、日付型を文字列で持ちたいんだ。検索楽なんだぁ~っという場合は、素直にインデックス付の計算列もったりすれば良いんでない?っと思ってみたりします。
(Oracleだと、関数Indexとかになるんかな?)

いちよう↑のようなものまであるのに、それでも日付型を文字列で持つ意味がわからん・・・

計算列などを仮想列としてではなく、実体として持つと、HDDの容量がぁ~というレベルなら、そもそも計算列にインデックスを付ける付けない以前の問題だしなぁ~。

2012年10月6日土曜日

Balsamiq Mockups For Desktop その2

問い合わせが戻ってきた。
そしてQAを見落としてたよorz

返信にURL乗っけてきてくれた。驚くほど丁寧な案内だ(´ρ`)

ってことで、こちらのURL・・・私がすっかり見落としたURLともいいます・・・

http://support.balsamiq.com/customer/portal/articles/105924

さて、早速申請だ。

2012年10月4日木曜日

Balsamiq Mockups For Desktop

外部設計でちらっとコメントしたこのソフト。

Balsamiq Mockups For Desktop
http://www.balsamiq.com/

ブロガーさんや、オープンソースの開発者用ライセンスが無くなったくさいorz

僅かな望みを託して、メールで問い合わせ中。

なかったら、あきらめて買うかどうか考えよう(´ρ`)

2012年10月1日月曜日

さて、仕事やることないし明日休むかと思ってたら・・・

どうやらでかい障害が起こってたらしい。
原因は、改行文字がTextBoxに入ってしまうという、笑えるジョークのようなものが原因。

修正箇所がべらぼーにあるらしく、駆り出される事に・・・(´ρ`)

本番稼働からすでに結構たってるのに、いまだにこの手のバグが出てくる開発から逃げ出したい

ってか、休んじゃおうかな・・・

やりたいことあるんだよね(´ρ`)

Entity FrameworkとかEnterprise Libraryのサンプル触っておきたいんだよねぇ~

(´-`) ンー