//файл xml.cs
namespace xml
{
  public class MyExtension
    {
          //
        public static void ToDB(this string source) 
                {...};
    }
}
//файл db.cs
namespace db
{
  public class MyExtension
    {
          //суммирует через базу данных
        public static void ToDB(this string source) 
                {...};
    }
}
//использование первого в файле бла1.cs
using xml;
.....
string str="bla1";
str.ToDB();
//использование второго возможно только в другом файле, например бла2.cs
using db;
........
string str="bla2";
str.ToDB();

//проверяем подключен-ли namespace DB
is_with(DB)
{
  string str="DB forever";
  str.ToDB();
}

with(DB)
{
  str.ToDB();
}

GZ>//проверяем подключен-ли namespace DB
GZ>is_with(DB)
GZ>{
GZ>  string str="DB forever";
GZ>  str.ToDB();
GZ>}
GZ>

GZ>with(DB)
GZ>{
GZ>  str.ToDB();
GZ>}
GZ>

module Xml
    def to_db
        puts "#{self} going to XML"
    end
end

module Db
    def to_db
        puts "#{self} going to DB"
    end
end

str1 = String.new( "bla1" )
str1.extend Xml

str2 = String.new( "bla2" )
str2.extend Db

str1.to_db
str2.to_db

bla1 going to XML
bla2 going to DB

#include <iostream>
#include <string>

namespace Xml
{
    inline void to_db( const std::string & s )
        {
            std::cout << s << " going to XML" << std::endl;
        }
}

namespace Db
{
    inline void to_db( const std::string & s )
        {
            std::cout << s << " going to DB" << std::endl;
        }
}

int main()
    {
        std::string str( "bla" );

        {
            using namespace Xml;
            to_db( str );
        }

        {
            using namespace Db;
            to_db( str );
        }
    }

bla going to XML
bla going to DB

class Generators

    @@generators = {}

    def Generators.add( file_name, generator ) ... end

    def Generators.all_files ... end

    def Generators.for_file( file_name ) ... end

end # class Generators

class Generators {
    friend class TC_CodegenInitiator;
    friend class TC_Generators;
private :
    //! Методы только для "своих".
    static void test_setup() { ... }
    static GeneratorsMap & test_all_generators() { ... };
public :
    //! Методы для всех остальных.
    ...
};

class Generators
    def Generators.test_setup
        @@generators = {}
    end
    def Generators.test_all_generators
        @@generators
    end
end

class Generators {
    protected :
        static GeneratorsMap generators;
    ...
};

class ExtendedGenerators : public Generators {
    public :
        static void test_setup() { generators.clear(); }
        static GeneratorsMap & test_all_generators() { return generators; }
};

class Generators {
    public :
        virtual void add(...) = 0;
        virtual const FileMap & all_files() = 0;
        virtual Generator & for_file(...) = 0;
        
        static Generators * instance();
};

class StdGenerators : public Generator {
    public :
        ...
        void test_setup() { ... }
        void GeneratorsMap & test_all_generators() { ... };
};

StdGenerators * g = dynamic_cast< StdGenerators * >( Generators::instance() );
g->test_setup();
...

a.ToDB();

1.1.4 stable rev. 510

MyObject mo = new MyObject();
ISome i = (ISomeObject)mo // здесь компилер еще может понять, что надо применить екстеншн для MyObject
object o = mo;
ISome i2 = (ISomeObject)o; // а вот здесь уже поехал cast на уровне MSIL, а он про наш сахар ничего не знает.

1.1.4 stable rev. 510

GZ> Получается некоторая бессмысленная игрушка.

GZ> Не наше собачье дело. Наше собачье дело сказать с помощью namespace что мы хотим работать с базой данных, или с xml.

using namespace Test;
namespace Test1
{
  public class SomeClass : Test.ISomeInterface
    {
      int ISomeInterface.A { get { return 1; }
    }
}

using namespace Test;
namespace Test2
{
  public class SomeClass : Test.ISomeInterface
    {
      int ISomeInterface.A { get { return 1; }
    }
}

using Test;
using Test2;
public class MyClass
{
  private static SomeClass _sc = new SomeClass();
    public static int GetA()
    {
      return _sc.A;
    }
}

System.Data.Common.DbConnection
System.Data.SqlClient.DbConnection
System.Data.OracleClient.DbConnection

System.Data.Common.DbConnection
System.Data.SqlClient.SqlConnection
System.Data.OracleClient.OracleConnection

GZ>Нее, перекрыть нельзя. И imho это правильно. Если есть метод подходящий в реальном типе, то компилятор плюет на все расширения.

1.1.4 stable rev. 510

GZ>> Получается некоторая бессмысленная игрушка.

GZ>> Не наше собачье дело. Наше собачье дело сказать с помощью namespace что мы хотим работать с базой данных, или с xml.

using Test;
using Test2;
public class MyClass
{
//абстрагируемся от реализации через интерфейс.
  private static ISomeInterface _sc=new Test.SomeClass() as ISomeInterface;
    public static int GetA()
    {
      return _sc.A;
    }
}

S>System.Data.Common.DbConnection
S>System.Data.SqlClient.DbConnection
S>System.Data.OracleClient.DbConnection
S>

S>System.Data.Common.DbConnection
S>System.Data.SqlClient.SqlConnection
S>System.Data.OracleClient.OracleConnection
S>

GZ>>Нее, перекрыть нельзя. И imho это правильно. Если есть метод подходящий в реальном типе, то компилятор плюет на все расширения.