using System.Xml;
using System.IO;
using GrapeCity.ActiveReports.Design;

using (var reportStream = File.OpenRead("DemoReport.rdlx"))
 {
     using (var reader = XmlReader.Create(reportStream))
      {
         designer1.LoadReport(reader, DesignerReportType.Page);
      }
 }

using System;

namespace CustomDataProvider.CSVDataProvider
{
        // データソース内のフィールドに関する情報を表します。
        internal struct CsvColumn
        {
                private readonly string _fieldName;
                private readonly Type _dataType;

                // CsvColumnクラスの新しいインスタンスを生成します。
                  // fieldNameはCsvColumnのインスタンスによって表されるフィールドの名前です。
                  // dataTypeはCsvColumnのインスタンスによって表されるフィールドの種類です。
                  public CsvColumn(string fieldName, Type dataType)
                {
                        if (fieldName == null)
                                throw new ArgumentNullException("fieldName");
                        if (dataType == null)
                                throw new ArgumentNullException("dataType");
                        _fieldName = fieldName;
                        _dataType = dataType;
                }


                // CsvColumnのインスタンスによって表されるフィールドの名前を取得します。
                  public string FieldName
                {
                        get { return _fieldName; }
                }


                //CsvColumnのインスタンスによって表されるフィールドの種類を取得します。
                  public Type DataType
                {
                        get { return _dataType; }
                }


               //CsvColumnのインスタンスを表わす文字列を返します。
                  public override string ToString()
                {
                        return String.Concat(new string[] {FieldName, "(", DataType.ToString(), ")"});
                }


                //2つのCsvColumnのインスタンスが同じかどうかを判定します。
                  //指定されたCsvColumnが現在のCsvColumnと同じである場合はTrueを返し、そうではない場合はFalseを返します。
                  public override bool Equals(object obj)
                {
                        bool flag;

                        if (obj is CsvColumn)
                        {
                                flag = Equals((CsvColumn) obj);
                        }
                        else
                        {
                                flag = false;
                        }
                        return flag;
                }

                private bool Equals(CsvColumn column)
                {
                        return column.FieldName == FieldName;
                }


                //ハッシュテーブルのようなハッシュアルゴリズムやデータ構造での使用に適した、CsvColumnのハッシュ関数として機能します。
                  //現在のCsvColumnインスタンスにハッシュコードを返します。
                  public override int GetHashCode()
                {
                        return (FieldName.GetHashCode() + DataType.GetHashCode());
                }
        }
}

using System;
using System.Collections;
using System.Globalization;
using System.IO;
using System.Text.RegularExpressions;
using GrapeCity.ActiveReports.Extensibility.Data;

namespace CustomDataProvider.CSVDataProvider
{

        //  .NET Framework CSV Data ProviderのIDataReaderの実施を提供します。
        internal class CsvDataReader :IDataReader
        {
             //メモ:HashcodeProviderとComparerは大文字と小文字を区別します。
               private Hashtable _typeLookup =
                        new Hashtable(StringComparer.Create(CultureInfo.InvariantCulture, false));
             private Hashtable _columnLookup = new Hashtable();
             private object[] _columns;
             private TextReader _textReader;
             private object[] _currentRow;


             //正規表現は、高速化するためにコンパイル済みです。
             //マルチスレッドに関係するため、このオブジェクトのプロパティを変更できないように読み取り専用に設定しています。
                private static readonly Regex _rxDataRow = new Regex(@",(?=(?:[^""]*""[^""]*"")*(?![^""]*""))", RegexOptions.Compiled);
                        //データ行の解析に使用します。

                private static readonly Regex _rxHeaderRow =
                        new Regex(@"(?<fieldName>(\w*\s*)*)\((?<fieldType>\w*)\)", RegexOptions.Compiled); 
                        //ヘッダ行の解析に使用します。

        
                // CsvDataReaderクラスの新しいインスタンスを生成します。
                // textReaderはデータを読みこむTextReaderを表します。
                public CsvDataReader(TextReader textReader)
                {
                        _textReader = textReader;
                        ParseCommandText();
                }

        
                // 渡したコマンドテキストを解析します。
                private void ParseCommandText()
                {
                        if (_textReader.Peek() == -1)
                                return; //Command text is empty or at the end already.

                        FillTypeLookup();

                        string header = _textReader.ReadLine();
                        header = AddDefaultTypeToHeader(header);

                        if (!ParseHeader(header))
                                throw new InvalidOperationException(
                                        "Field names and types are not defined.The first line in the CommandText must contain the field names and data types. e.g FirstName(string)");
                }

                //ハッシュテーブルはヘッダテキストに使用される文字列のデータ型を返却するために使用します。
                private void FillTypeLookup()
                {
                        _typeLookup.Add("string", typeof (String));
                        _typeLookup.Add("byte", typeof (Byte));
                        _typeLookup.Add("boolean", typeof (Boolean));
                        _typeLookup.Add("datetime", typeof (DateTime));
                        _typeLookup.Add("decimal", typeof (Decimal));
                        _typeLookup.Add("double", typeof (Double));
                        _typeLookup.Add("int16", typeof (Int16));
                        _typeLookup.Add("int32", typeof (Int32));
                        _typeLookup.Add("int", typeof (Int32));
                        _typeLookup.Add("integer", typeof (Int32));
                        _typeLookup.Add("int64", typeof (Int64));
                        _typeLookup.Add("sbyte", typeof (SByte));
                        _typeLookup.Add("single", typeof (Single));
                        _typeLookup.Add("time", typeof (DateTime));
                        _typeLookup.Add("date", typeof (DateTime));
                        _typeLookup.Add("uint16", typeof (UInt16));
                        _typeLookup.Add("uint32", typeof (UInt32));
                        _typeLookup.Add("uint64", typeof (UInt64));
                }

        
              // ヘッダテキストの文字列から渡された値に基づいてデータ型を返却します。適合しない場合は、文字列型を返却します。
                // fieldTypeパラメータはヘッダコマンドテキストStringのString値を代表します。
                private Type GetFieldTypeFromString(string fieldType)
                {
                        if (_typeLookup.Contains(fieldType))
                                return _typeLookup[fieldType] as Type;
                        return typeof (String);
                }

        
              // 渡したコマンドテキストの最初の行を解析してフィールド名とフィールドデータ型を生成します。
                // フィールド情報はCsvColumn 構造体に保存し、列の情報アイテムはArrayListに保存します。
                // 後で参照しやすくするために、ハッシュテーブルに列名も付けます。        
                // ヘッダパラメータはヘッダ文字列を表し、すべてのフィールドを含めます。
                // ヘッダ文字列を解析できる場合はTrueを返し、そうではない場合はFalseを返します。
                private bool ParseHeader(string header)
                {
                        string fieldName;
                        int index = 0;
                        if (header.IndexOf("(") == -1)
                                return false;

                        MatchCollection matches = _rxHeaderRow.Matches(header);
                        _columns = new object[matches.Count];
                        foreach (Match match in matches)
                        {
                                fieldName = match.Groups["fieldName"].Value;
                                Type fieldType = GetFieldTypeFromString(match.Groups["fieldType"].Value);
                                _columns.SetValue(new CsvColumn(fieldName, fieldType), index);
                                _columnLookup.Add(fieldName, index);
                                index++;
                        }

                        return true;
                }

        
              // ヘッダに名前の形式の列が含まれていることを確認します。
                // lineパラメータはファイルから解析したに列ヘッダ行を表します。
                // カラム名に付加するデフォルト型の変更されたヘッダを返却します。
                private static string AddDefaultTypeToHeader(string line)
                {
                        const string ColumnWithDataTypeRegex = @"[""]?\w+[\""]?\(.+\)";
                        string[] columns = line.Split(new string[] { "," }, StringSplitOptions.None);
                        string ret = null;
                        foreach (string column in columns)
                        {
                                if (!string.IsNullOrEmpty(ret))
                                        ret += ",";
                                if (!Regex.Match(column, ColumnWithDataTypeRegex).Success)
                                {
                                        ret += column + "(string)";
                                }
                                else
                                {
                                        ret += column;
                                }
                        }
                        return ret;
                }

        
              // 正規表現を使用して、データの行を解析し、データの現在の行にあるオブジェクト配列内の情報を格納します。
                // 行が正しいフィールド数でない場合、例外が発生します。
                // DataRowは、カンマ区切りのデータ行を表す文字列型（String）の値を表します。
                // データを解析できる場合はTrueを返し、そうではない場合はFalseを返します。
                private bool ParseDataRow(string dataRow)
                {
                        int index = 0;
                        string[] tempData = _rxDataRow.Split(dataRow);

                        _currentRow = new object[tempData.Length];
                        if (tempData.Length != _columns.Length)
                        {
                                string error =
                                        string.Format(CultureInfo.InvariantCulture,
                                                      "Invalid row \"{0}\".The row does not contain the same number of data columns as the table header definition.",
                                                      dataRow);
                                throw new InvalidOperationException(error);
                        }
                        for (int i = 0; i < tempData.Length; i++)
                        {
                                string value = tempData[i];

                                if (value.Length > 1)
                                {
                                        if (value.IndexOf('"', 0) == 0 && value.IndexOf('"', 1) == value.Length - 1)
                                                value = value.Substring(1, value.Length - 2);
                                }
                                _currentRow.SetValue(ConvertValue(GetFieldType(index), value), index);
                                index++;
                        }
                        return true;
                }

        
              // コマンドテキストからの文字列値を、フィールドの種類によって適当なデータ型に変更します。
                // System.Data.DBNullのString.Emptyを返すかどうかを決めるのに文字列値の規則を確認します。
                // typeパラメータはデータが属する現在の列の種類を表します。
                // originalValueはコマンドテキストからの文字列値を表します。
                // 変更したStringからのオブジェクトを種類に応じて返します。
                private object ConvertValue(Type type, string originalValue)
                {
                        Type fieldType = type;
                        CultureInfo invariantCulture = CultureInfo.InvariantCulture;
                        try
                        {
                                if (originalValue == "\"\"" || originalValue == " ")
                                        return string.Empty;
                                if (originalValue == "")
                                        return DBNull.Value;
                                if (originalValue == "DBNull")
                                        return DBNull.Value;
                                if (fieldType.Equals(typeof (String)))
                                        return originalValue.Trim();
                                if (fieldType.Equals(typeof (Int32)))
                                        return Convert.ToInt32(originalValue, invariantCulture);
                                if (fieldType.Equals(typeof (Boolean)))
                                        return Convert.ToBoolean(originalValue, invariantCulture);
                                if (fieldType.Equals(typeof (DateTime)))
                                        return Convert.ToDateTime(originalValue, invariantCulture);
                                if (fieldType.Equals(typeof (Decimal)))
                                        return Convert.ToDecimal(originalValue, invariantCulture);
                                if (fieldType.Equals(typeof (Double)))
                                        return Convert.ToDouble(originalValue, invariantCulture);
                                if (fieldType.Equals(typeof (Int16)))
                                        return Convert.ToInt16(originalValue, invariantCulture);
                                if (fieldType.Equals(typeof (Int64)))
                                        return Convert.ToInt64(originalValue, invariantCulture);
                                if (fieldType.Equals(typeof (Single)))
                                        return Convert.ToSingle(originalValue, invariantCulture);
                                if (fieldType.Equals(typeof (Byte)))
                                        return Convert.ToByte(originalValue, invariantCulture);
                                if (fieldType.Equals(typeof (SByte)))
                                        return Convert.ToSByte(originalValue, invariantCulture);
                                if (fieldType.Equals(typeof (UInt16)))
                                        return Convert.ToUInt16(originalValue, invariantCulture);
                                if (fieldType.Equals(typeof (UInt32)))
                                        return Convert.ToUInt32(originalValue, invariantCulture);
                                if (fieldType.Equals(typeof (UInt64)))
                                        return Convert.ToUInt64(originalValue, invariantCulture);
                        }
                        catch (Exception e)
                        {
                                throw new InvalidOperationException(
                                        string.Format("Input value '{0}' could not be converted to the type '{1}'.", originalValue, type), e);
                        }
                        //一致しない場合、DBNullを返します。
                        return DBNull.Value;
                }

                #region IDataReader Members

        
              // CsvDataReaderは次のレコードに進みます。
                // それ以上の行がある場合はTrueを返し、そうではない場合はFalseを返します。
                public bool Read()
                {
                        if (_textReader.Peek() > -1)
                                ParseDataRow(_textReader.ReadLine());
                        else
                                return false;

                        return true;
                }

                #endregion

                #region IDisposable Members

        
              // CsvDataReaderに使用されるリソースを出します。
                public void Dispose()
                {
                        Dispose(true);
                        GC.SuppressFinalize(this);
                }

                private void Dispose(bool disposing)
                {
                        if (disposing)
                        {
                                if (_textReader != null)
                                        _textReader.Close();
                        }

                        _typeLookup = null;
                        _columnLookup = null;
                        _columns = null;
                        _currentRow = null;
                }

        
             // オブジェクトがガベージコレクションによってクリアされる前に、そのオブジェクトがリソースを解放し、
               // その他のクリーンアップ操作を実行できるようにします。
                ~CsvDataReader()
                {
                        Dispose(false);
                }

                #endregion

                #region IDataRecord Members

        
                // 現在の行に列の数字を取得します。
                public int FieldCount
                {
                        get { return _columns.Length; }
                }

        
              // iは探すフィールドのインデックスを表します。
                // GetValueから返される、オブジェクトの型に対応する型の情報を返却します。
                public Type GetFieldType(int i)
                {
                        if (i > _columns.Length - 1)
                                return null;

                        return ((CsvColumn) _columns.GetValue(i)).DataType;
                }

        
              // 探すフィールドの名前を取得します。
                // iは探すフィールドのインデックスを表します。
                // 返却する値がない場合は、フィールドの名前か、空文字 ("")を返します。
                public string GetName(int i)
                {
                        if (i > _columns.Length - 1)
                                return string.Empty;


                        return ((CsvColumn) _columns.GetValue(i)).FieldName;
                }

        
              // nameパラメータは探すフィールドの名前を表します。
                // 指定されたフィールドのインデックスを返却します。
                public int GetOrdinal(string name)
                {
                        object value = _columnLookup[name];
                        if (value == null)
                                throw new IndexOutOfRangeException("name");
                        return (int) value;
                }

        
              // iは探すフィールドのインデックスを表します。
                // 指定されたフィールドの値を含むオブジェクトを返します。
                public object GetValue(int i)
                {
                        if (i > _columns.Length - 1)
                                return null;

                        return _currentRow.GetValue(i);
                }

                public virtual IDataReader GetData(int fieldIndex)
                {
                        throw new NotSupportedException();
                }

                #endregion
        }
}

using System;
using System.IO;
using GrapeCity.ActiveReports.Extensibility.Data;

namespace CustomDataProvider.CSVDataProvider
{

       // .NET Framework CSV Data ProviderのIDbCommandの実施を提供します。
        public sealed class CsvCommand :IDbCommand
        {
                private string _commandText;
                private IDbConnection _connection;
                private int _commandTimeout;
                private CommandType _commandType;

        
                /// Creates a new instance of the CsvCommand class.
                public CsvCommand()
                        : this(string.Empty)
                {
                }

        
              // コマンドテキストのあるCsvCommandクラスの新しいインスタンスを生成します。
                // commandTextパラメータはコマンドテキストを表します。
                public CsvCommand(string commandText)
                        : this(commandText, null)
                {
                }

        
              // コマンドテキストとCsvConnectionがあるCsvCommandクラスの新しいインスタンスを生成します。
                // commandTextパラメータ、コマンドテキストを表します。
                // connectionパラメータは、データソースとCsvConnectionを表します。
                public CsvCommand(string commandText, CsvConnection connection)
                {
                        _commandText = commandText;
                        _connection = connection;
                }

        
                // データソースで実行するコマンドを取得、設定します。
                public string CommandText
                {
                        get { return _commandText; }
                        set { _commandText = value; }
                }

        
                // コマンド実行の試行を終了し、エラーを生成するまでの待機時間を取得、設定します。
                public int CommandTimeout
                {
                        get { return _commandTimeout; }

                        set { _commandTimeout = value; }
                }

        
                // CommandTextプロパティの解放を指示する値を取得、設定します。
                public CommandType CommandType
                {
                        get { return _commandType; }

                        set { _commandType = value; }
                }

        
               // CsvCommandのインスタンスに使用するCsvConnectionの値を取得、設定します。
                public IDbConnection Connection
                {
                        get { return _connection; }

                        set { _connection = value; }
                }

        
              // CommandTextをCsvConnectionに送信し、いずれかのCommandBehavior値を使用し、CsvDataReaderをビルドします。
                // behaviorパラメータはCommandBehaviorの値を表します。
                // CsvDataReaderオブジェクトを返却。
                public IDataReader ExecuteReader(CommandBehavior behavior)
                {
                        return new CsvDataReader(new StreamReader(_commandText));
                }

        
               // 定数に拡張パラメータを指定したコマンドテキストを表わす文字列を返却します。
                public string GenerateRewrittenCommandText()
                {
                        return _commandText;
                }

        
              // CommandTextをCsvConnectionに送信し、CsvDataReaderをビルドします。
                // CsvDataReaderオブジェクトを返します。
                public IDataReader ExecuteReader()
                {
                        return ExecuteReader(CommandBehavior.SchemaOnly);
                }

                #region Non implemented IDbCommand Members

                public IDataParameterCollection Parameters
                {
                        get { throw new NotImplementedException(); }
                }

                public IDbTransaction Transaction
                {
                        get { throw new NotImplementedException(); }

                        set { throw new NotImplementedException(); }
                }

                public void Cancel()
                {
                        
                }

                public IDataParameter CreateParameter()
                {
                        throw new NotImplementedException();
                }

                #endregion

                #region IDisposable Members

        
                // CsvCommandに使用するリソースを放出します。
                public void Dispose()
                {
                        Dispose(true);
                        GC.SuppressFinalize(this);
                }


                private void Dispose(bool disposing)
                {
                        if (disposing)
                        {
                                if (_connection != null)
                                {
                                        _connection.Dispose();
                                        _connection = null;
                                }
                        }
                }

                #endregion
        }
}

using System;
using System.Collections.Specialized;
using GrapeCity.ActiveReports.Extensibility.Data;

namespace CustomDataProvider.CSVDataProvider
{

        // .NET Framework CSV Data ProviderのIDbConnectionの実施を提供します。
        public sealed class CsvConnection :IDbConnection
        {
                private string _localizedName;

        
                // CsvConnectionクラスの新しいインスタンスを生成します。
                public CsvConnection()
                {
                        _localizedName = "Csv";
                }

        
                // CsvConnectionクラスの新しいインスタンスを生成します。
                // ocalizedNameはCsvConnectionのインスタンスのローカライズ名を表します。
                public CsvConnection(string localizeName)
                {
                        _localizedName = localizeName;
                }

                #region IDbConnection Members

        
              // データソースに接続の開始に使用する文字列を取得、設定します。
                // 備考:Csv Data Providerでは使いません。
                public string ConnectionString
                {
                        get { return string.Empty; }

                        set { ; }
                }

        
                // 接続を確立する際の待機時間を取得、設定します。
                // 備考:Csv Data Providerでは使いません。
                public int ConnectionTimeout
                {
                        get { throw new NotImplementedException(); }
                }

        
               // データソースとのトランザクションを開始します。 
               // 新しいトランザクションを表わすオブジェクトを返します。
               // 備考:Csv Data Providerには使いません。
                public IDbTransaction BeginTransaction()
                {
                        return null;
                }

        
               // データソースとの接続を開きます。     
               // 備考:Csv Data Providerには使いません。
                public void Open()
                {
                        ;
                }

        
                // データソースとの接続を閉じます。これは、接続を閉じるために推奨される方法です。
                public void Close()
                {
                        Dispose();
                }

        
               // CsvConnectionに関連付けたCsvCommandオブジェクトを生成し、返却します。
                public IDbCommand CreateCommand()
                {
                        return new CsvCommand(string.Empty);
                }

                public IDataProviderService DataProviderService
                {
                        get { return null; }
                        set { }
                }

                #endregion

                #region IDisposable Members

        
               // CsvConnectionに使用するリソースを解放します。
                public void Dispose()
                {
                        Dispose(true);
                        GC.SuppressFinalize(this);
                }

                private void Dispose(bool disposing)
                {
                }

        
                // オブジェクトがガベージコレクションによってクリアされる前に、そのオブジェクトがリソースを解放し、
                // その他のクリーンアップ操作を実行できるようにします。
                ~CsvConnection()
                {
                        Dispose(false);
                }

                #endregion

                #region IExtension Members

        
                // CsvConnectionのローカライズ名を取得します。
                public string LocalizedName
                {
                        get { return _localizedName; }
                }

        
                // この拡張子の構成情報を指定します。
                // configurationSettingsは設定のNameValueCollectionを表します。
                public void SetConfiguration(NameValueCollection configurationSettings)
                {
                }

                #endregion
        }
}

using GrapeCity.ActiveReports.Extensibility.Data;
using GrapeCity.BI.Data.DataProviders;

namespace CustomDataProvider.CSVDataProvider
{

       // .NET Framework CSV Data ProviderのDataProviderFactoryを実施します。
        public class CsvDataProviderFactory :DataProviderFactory
        {
        
                // CsvDataProviderFactoryクラスの新しいインスタンスを生成します。
                public CsvDataProviderFactory()
                {
                }
        
               // CsvCommandの新しいインスタンスを返します。
                public override IDbCommand CreateCommand()
                {
                        return new CsvCommand();
                }
        
               // CsvConnectionの新しいインスタンスを返します。
                public override IDbConnection CreateConnection()
                {
                        return new CsvConnection();
                }
        }
}

using System;
using System.Collections.Generic;
using System.Drawing.Design;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Windows.Forms;
using System.Windows.Forms.Design;

namespace CustomDataProvider.CSVDataProvider
{
        public sealed class QueryEditor :UITypeEditor
        {
                public override UITypeEditorEditStyle GetEditStyle(System.ComponentModel.ITypeDescriptorContext context)
                {
                        return UITypeEditorEditStyle.DropDown;
                }

                public override object EditValue(System.ComponentModel.ITypeDescriptorContext context, System.IServiceProvider provider, object value)
                {
                        IWindowsFormsEditorService edSvc = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
                        var path = "";
                        var btn = new Button();
                        btn.Text = "Select CSV File...";
                        var pdg = btn.Padding;
                        pdg.Bottom += 2;
                        btn.Padding = pdg;

                        btn.Click += delegate
                                        {
                                                using (var openDlg = new OpenFileDialog())
                                                {
                                                        openDlg.Filter = "CSV Files (*.csv)|*.csv|All Files (*.*)|*.*";
                                                        if (openDlg.ShowDialog() != DialogResult.OK)
                                                                path = "";
                                                        else
                                                                path = openDlg.FileName;
                                                }
                                        };
                        

                        edSvc.DropDownControl(btn);

                        if (string.IsNullOrEmpty(path)) return string.Empty;
                        if (!File.Exists(path)) return string.Empty;
                        
                        return path;
                }
        }
}