// csc /r:BLToolkit.3.dll /d:EXAMPLE1 bug.cs
// csc /r:BLToolkit.3.dll bug.cs

using System;
using System.IO;
using System.Text;
using BLToolkit.Data;
using BLToolkit.DataAccess;
using BLToolkit.Data.DataProvider;
using BLToolkit.Mapping;
using BLToolkit.Reflection.Extension;

public class Sample
{
    public class SomeClass
    {
        public int SomeValue { get; set; }
    }

    static void Main()
    {
        // для провайдера MsSql баг проявляется немного иначе
        DbManager.AddDataProvider(typeof(OdpDataProvider));
        DbManager.AddConnectionString("Odp", "Data Source=(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=DBHost)(PORT=1521))(CONNECT_DATA=(SERVICE_NAME=XE)));User Id=TestUser;Password=TestPassword;");

        // Должно быть:
        //
        // SELECT
        //        SOME_VALUE
        // FROM
        //        SOME_TABLE

#if EXAMPLE1
        // SELECT
        //        SOME_VALUE
        // FROM
        //        SomeClass

        using (var db = new DbManager())
        {
            db.MappingSchema.Extensions = TypeExtension.GetExtensions(Mappings);
            var query = new SqlQuery<SomeClass>();
            Console.WriteLine(query.GetSqlQueryInfo(db, "SelectAll").QueryText);
        }
#else
        // SELECT
        //        SomeValue
        // FROM
        //        SOME_TABLE

        using (var db = new DbManager())
        {
            var query = new SqlQuery<SomeClass>();
            query.Extensions = TypeExtension.GetExtensions(Mappings);
            Console.WriteLine(query.GetSqlQueryInfo(db, "SelectAll").QueryText);
        }
#endif
    }

    static Stream Mappings
    {
        get
        {
            return new MemoryStream(Encoding.UTF8.GetBytes(@"<?xml version='1.0' encoding='utf-8' ?>
                <Types xmlns='urn:schemas-bltoolkit-net:typeext' xmlns:da='urn:schemas-bltoolkit-net:dataaccess'>

                    <Type Name='SomeClass' da:TableName='SOME_TABLE'>
                        <Member Name='SomeValue' MapField='SOME_VALUE' />
                    </Type>

                </Types>"));
        }
    }
}

db.MappingSchema.Extensions = TypeExtension.GetExtensions(Mappings);
query.Extensions = db.MappingSchema.Extensions;

protected SqlQueryInfo CreateSelectAllSqlText(DbManager db, Type type)
{
    ObjectMapper  om    = db.MappingSchema.GetObjectMapper(type);
    StringBuilder sb    = new StringBuilder();
    SqlQueryInfo  query = new SqlQueryInfo(om);

    sb.Append("SELECT\n");

    foreach (MemberMapper mm in GetFieldList(om))
        sb.AppendFormat("\t{0},\n",
            db.DataProvider.Convert(mm.Name, ConvertType.NameToQueryField));

    sb.Remove(sb.Length - 2, 1);

    sb.AppendFormat("FROM\n\t{0}",
        db.DataProvider.Convert(GetTableName(type), ConvertType.NameToQueryTable));

    query.QueryText = sb.ToString();

    return query;
}

string       key   = type.FullName + "$" + actionName + "$" + db.DataProvider.UniqueName + "$" + GetTableName(type);

ili>string key = type.FullName + "$" + actionName + "$" + db.DataProvider.UniqueName + "$" + GetTableName(type);
ili>

protected SqlQueryInfo Create...SqlText(DbManager db, Type type)
{
    // было: ObjectMapper om = db.MappingSchema.GetObjectMapper(type);
    ObjectMapper om = MappingSchema.GetObjectMapper(type);
    ...

ili>а вообще, конечно, все это крайне непрозрачно

using (var db = new DbManager())
{
    // общедоступные TypeExtensions
    db.MappingSchema.Extensions = LoadPublicExtensions();

    // UserCode использует схему маппинга из DbManager
    CallUserCode(db);

    // а здесь используются другие TypeExtensions, недоступные для UserCode
    var query = new SqlQuery<SomeSystemClass>();
    query.MappingSchema.Extensions = LoadPrivateExtensions();
    ...

    // снова используется public-схема
    СallAnotherUserCode(db);
}

W>Разве это правильно?

private MappingSchema _mappingSchema = Map.DefaultSchema;
public  MappingSchema  MappingSchema
{
    [DebuggerStepThrough]
    get { return _mappingSchema; }
    set { _mappingSchema = value ?? Map.DefaultSchema; }
}

public virtual void InitDbManager(DbManager dbManager)
{
    MappingSchema schema = MappingSchema;

    if (schema != null)
        dbManager.MappingSchema = schema;
}

// csc Sample.cs /r:BLToolkit.3.dll

using System;
using System.IO;
using System.Text;
using BLToolkit.Data;
using BLToolkit.Data.DataProvider;
using BLToolkit.DataAccess;
using BLToolkit.Mapping;
using BLToolkit.Reflection;
using BLToolkit.Reflection.Extension;

public class SomeClass
{
    public int SomeValue { get; set; }
}

static class Program
{
    static void Main()
    {
        DbManager.AddDataProvider(typeof(OdpDataProvider));
        DbManager.AddConnectionString("Odp", "...");

        using (var db = new DbManager())
        {
            // общедоступные TypeExtensions
            db.MappingSchema.Extensions = TypeExtension.GetExtensions(PublicMappings);
      
            // UserCode использует схему из DbManager
            CallUserCode(db);
      
            // а здесь используются другие TypeExtensions, недоступные для UserCode
            var query = new SqlQuery<SomeClass>
            {
                MappingSchema = new MappingSchema
                {
                    Extensions = TypeExtension.GetExtensions(PrivateMappings)
                }
            };

            // Должно быть:
            // SELECT
            //        SOME_SYSTEM_VALUE
            // FROM
            //        SOME_SYSTEM_TABLE

            Console.WriteLine("-- private mappings:");
            Console.WriteLine("{0}\n", query.GetSqlQueryInfo(db, "SelectAll").QueryText);

            // снова используется public-схема
            CallUserCode(db);
        }
    }

    static void CallUserCode(DbManager db)
    {
        // Должно быть:
        // SELECT
        //        SOME_VALUE
        // FROM
        //        SOME_TABLE

        Console.WriteLine("-- public mappings:");
        var query = new SqlQuery<SomeClass>();
        Console.WriteLine("{0}\n", query.GetSqlQueryInfo(db, "SelectAll").QueryText);
    }

    static Stream PublicMappings
    {
        get
        {
            return new MemoryStream(Encoding.UTF8.GetBytes(@"<?xml version='1.0' encoding='utf-8' ?>
                <Types xmlns='urn:schemas-bltoolkit-net:typeext' xmlns:da='urn:schemas-bltoolkit-net:dataaccess'>
                    <Type Name='SomeClass' da:TableName='SOME_TABLE'>
                        <Member Name='SomeValue' MapField='SOME_VALUE' />
                    </Type>
                </Types>"));
        }
    }

    static Stream PrivateMappings
    {
        get
        {
            return new MemoryStream(Encoding.UTF8.GetBytes(@"<?xml version='1.0' encoding='utf-8' ?>
                <Types xmlns='urn:schemas-bltoolkit-net:typeext' xmlns:da='urn:schemas-bltoolkit-net:dataaccess'>
                    <Type Name='SomeClass' da:TableName='SOME_SYSTEM_TABLE'>
                        <Member Name='SomeValue' MapField='SOME_SYSTEM_VALUE' />
                    </Type>
                </Types>"));
        }
    }
}

-- public mappings:
SELECT
        SOME_VALUE
FROM
        SomeClass

-- private mappings:
SELECT
        SOME_VALUE
FROM
        SOME_SYSTEM_TABLE

-- public mappings:
SELECT
        SOME_VALUE
FROM
        SomeClass

W>>Разве это правильно?

ili>так, что все правила заточены под скорость работы

SELECT
        SOME_VALUE
FROM
        SomeClass