public class CategoryInfo
{
    public int    CategoryID;
    public string CategoryName;
    public int    Count;
}

static ArrayList GetCategories(int min)
{
    string connectionString =
        "Server=.;Database=Northwind;Integrated Security=SSPI";
    string commandText = @"
        SELECT 
            p.CategoryID,
            c.CategoryName,
            Count(p.CategoryID) Count
        FROM Products p
            INNER JOIN Categories c ON c.CategoryID = p.CategoryID
        GROUP BY p.CategoryID, c.CategoryName
        HAVING Count(p.CategoryID) >= @min
        ORDER BY c.CategoryName";

    using (SqlConnection con = new SqlConnection(connectionString))
    {
        con.Open();

        using (SqlCommand cmd = new SqlCommand(commandText, con))
        {
            cmd.Parameters.Add("@min", min);

            using (SqlDataReader rd = cmd.ExecuteReader())
            {
                ArrayList al = new ArrayList();

                while (rd.Read())
                {
                    CategoryInfo ci = new CategoryInfo();

                    ci.CategoryID   = Convert.ToInt32 (rd["CategoryID"]);
                    ci.CategoryName = Convert.ToString(rd["CategoryName"]);
                    ci.Count        = Convert.ToInt32 (rd["Count"]);

                    al.Add(ci);
                }

                return al;
            }
        }
    }
}

public class CategoryInfo
{
    public int    CategoryID;
    public string CategoryName;
    public int    Count;
}

static ArrayList GetCategories(int min)
{
    using (DbManager db = DbManager.Open())
    {
        return db.ExecuteList(
            typeof(CategoryInfo), @"
            SELECT 
                p.CategoryID,
                c.CategoryName,
                Count(p.CategoryID) Count
            FROM Products p
                INNER JOIN Categories c ON c.CategoryID = p.CategoryID
            GROUP BY p.CategoryID, c.CategoryName
            HAVING Count(p.CategoryID) >= @min
            ORDER BY c.CategoryName",
            db.Parameter("@min", min));
    }
}

public class Accumulator< T > {
    private T val_;
    public void Add( T x ) {
        val_ = val_ + x;  //  oops!  what +?
    }
}

public interface Addable< T > {
    void Add( T x, T y );
}

public class Accumulator< T, AddT > where AddT : Addable< T > {
    private T val_;
    public void Add( T x ) {
        AddT addt = new AddT();        //  even this is impossible
        val_ = addt.AddT( val_, x );
    }
}

public class AddableInt : Addable< int > {
    public void Add( int x, int y ) { return x + y; }
}

//  now I can do this
Accumulator< int, AddableInt > acc;

public class Accumulator< T, AddT > where AddT : Addable< T > {
    private T val_;
    private AddT addt_;
    public Accumulator( AddT a ) { addt_ = a; }    //  come on!
    public void Add( T x ) {
        val_ = addt_.Add( val_, x );        //  virtual function call!
    }
}

public class Accumulator< T > {
    private T val_;
    private Addable< T > addt_;
    //  ...
}

template < typename T >
class Accumulator
{
    T val_;
public:    Accumulator< T > & operator+=( T const & x ) {
        val_ = val_ + x;    //  even val_ += x;
                    //  this call will be resolved at compile time
        return * this;
    }
};

template< typename Iter >
Iter find( Iter begin, Iter end
    , typename Iter::value_type const & what
        // this is impossible in C# with generics,
        // because value_type is a typedef
    ) {
    for ( Iter it = begin; it != end; ++it )
        if ( * it == what )
            break;
    return it;
}

//  usage
vector< int > v;
vector< int >::iterator pos = find( v.begin(), v.end(), 5 );

public class Finder< EnumT, ElemT, CompT > where
    EnumT : IEnumerator< ElemT >
    , CompT : IComparable< ElemT >
{
    public Finder( CompT comp ) { comp_ = comp; }
    public EnumT Find( EnumT it, ElemT x ) {
        while ( it.MoveNext() )
            if ( ! comp_.CompareTo( it.Current, x ) )
                break;
        return it;
    }
}

//  usage
class CompareInt : IComparable< int >
{
    public int CompareTo( int x, int y ) { return x - y; }
}

//  Enumerator< int > should be already defined

ArrayList< int > v;
Finder< Enumerator< int >, int, CompareInt > find = new Finder < Enumerator< int >, int, CompareInt >( new CompareInt() );
Enumerator< int > pos = find.Find( v.GetEnumerator(), 5 );

VD>А новой парадигмы и не нужно. Нужно расширение дотнета позволяющее писать более эффективные и безопастные приложения. Парадигмы же достаточно и той что есть.

delegate void op(Form ctl);

static void MyOp(Control f){}

op oper1 = new op(MyOp); // не компилится
op oper2 = new op(ctl){MyOp(ctl)}; // будет компилиться

   Hashtable<Integer, String> h = new Hashtable<Integer, String>();

One limitation to type variables in Tiger is that they must be instantiated with reference types -- primitive types won't work. So, in the example above, if we wanted to instead create a Hashtable mapping ints to Strings, we couldn't do it.

That's unfortunate, because it means that you have to wrap primitive types whenever you want to use them as arguments to a generic type. On the other hand, that's no worse than the current situation; you can't pass an int as a key to Hashtable because all keys must be of type Object.

What we'd really like to see would be automatic boxing and unboxing of primitive types, similar to what is done in C# (except better). Unfortunately, Tiger is not scheduled to include autoboxing of primitives (but one can always hope for Java 1.6!).

Good news! After this article was written, autoboxing was added to the Java 1.5 spec!

[MenuText("Открыть файл"), Shotrcut(Keys.Ctrl & Keys.O), Img("FileOpen")]
void OpetFile(){ ... }

#pragma once
#define MINIX_SELF()\
        SelfType* Self()        {return static_cast<        SelfType*>(this);}\
const    SelfType* Self()const    {return static_cast<const    SelfType*>(this);}

#pragma once
template<class SelfType>
struct SingleThread
{
    struct Locker
    {
        Locker(SelfType*){}
    private:
        Locker(const Locker&);
        Locker&operator=(const Locker&);
    };
    struct StaticLocker
    {
        StaticLocker(SelfType*){}
    private:
        StaticLocker(const StaticLocker&);
        StaticLocker&operator=(const StaticLocker&);
    };
};
template<class SelfType>
struct MultiThread
{
    struct Locker
    {
        Locker(SelfType* self)
            :self_(self)
        {
            self_->cs_.Lock();
        }
        ~Locker()
        {
            self_->cs_.Unlock();
        }
    private:
        Locker(const Locker&);
        Locker&operator=(const Locker&);
        MultiThread* self_;
    };
    struct StaticLocker
    {
        StaticLocker(SelfType* self)
            :self_(self)
        {
            self_->scs_.Lock();
        }
        ~StaticLocker()
        {
            self_->scs_.Unlock();
        }
    private:
        StaticLocker(const StaticLocker&);
        StaticLocker&operator=(const StaticLocker&);
        MultiThread* self_;
    };
private:
    struct CS{void Lock(){}void Unlock(){}};
    CS cs_;
    static CS scs_;
};
template<class SelfType>
typename MultiThread<SelfType>::CS MultiThread<SelfType>::scs_;

#define SelfLock()            SelfType::Locker        locker(Self());
#define SelfStaticLock()    SelfType::StaticLocker    staticLocker(Self());

#pragma once
#include "mixin.h"
#include "Thread.h"
struct ITest1
{
    virtual void Test1Fn1()=0;
    virtual void Test1Fn2()=0;
    virtual void Test1Fn3()=0;
};
template<class SelfType>
struct ImplTest1:ITest1
{
    MINIX_SELF()
    void Test1Fn1()
    {
        SelfLock()
        Self()->Impl2();
    }
    void Test1Fn2()
    {
        Self()->Impl3();
    }
    void Test1Fn3()
    {
        SelfLock()
        Self()->Impl1();
    }
    void Impl1()
    {
    }
};

#pragma once
#include "mixin.h"
#include "Thread.h"
struct ITest2
{
    virtual void Test2Fn1()=0;
    virtual void Test2Fn2()=0;
    virtual void Test2Fn3()=0;
};
template<class SelfType>
struct ImplTest2:ITest2
{
    MINIX_SELF()
    void Test2Fn1()
    {
        Self()->Impl3();
    }
    void Test2Fn2()
    {
        SelfLock()
        Self()->Impl1();
    }
    void Test2Fn3()
    {
        SelfStaticLock()
        Self()->Impl2();
    }
    void Impl2()
    {
    }
};

#pragma once
#include "mixin.h"
#include "Thread.h"
struct ITest3
{
    virtual void Test3Fn1()=0;
    virtual void Test3Fn2()=0;
    virtual void Test3Fn3()=0;
};
template<class SelfType>
struct ImplTest3:ITest3
{
    MINIX_SELF()
    void Test3Fn1()
    {
        SelfStaticLock()
        Self()->Impl2();
    }
    void Test3Fn2()
    {
        SelfStaticLock()
        Self()->Impl1();
    }
    void Test3Fn3()
    {
        SelfLock()
        Self()->Impl3();
    }
    void Impl3()
    {
    }
};
template<class SelfType>
struct Impl2Test3:ITest3
{
    MINIX_SELF()
    void Test3Fn1()
    {
        SelfStaticLock()
        Self()->Impl2();
    }
    void Test3Fn2()
    {
        SelfStaticLock()
        Self()->Impl1();
    }
    void Test3Fn3()
    {
        SelfLock()
        Self()->Impl3();
    }
};

#include "stdafx.h"
#include "ITest1.h"
#include "ITest2.h"
#include "ITest3.h"

struct Test1
    :MultiThread<Test1>
    ,ImplTest1<Test1>
    ,ImplTest2<Test1>
    ,ImplTest3<Test1>
{
};

struct Test2
    :SingleThread<Test2>
    ,ImplTest1<Test2>
    ,ImplTest2<Test2>
    ,Impl2Test3<Test2>
{
    void Impl3()
    {
    }
};

int main()
{
    Test1 t1;
    Test2 t2;
    return 0;
}

| list |
list := #(10.0 20.0).
#(+ - / *) collect: [:op | list fold: [:a :b | a perform: op with: b]]

#(30.0 -10.0 0.5 200.0)

VD>Да я вроде и без него в С++ разбирался.

Если, прочитав материал, посвященный спискам типов, вы не свалились со стула, значит, вы сидели на полу.

// --------------------------------------------------------------------
// A little helper class for setting a boolean flag and clearing it
// on destruction.
class BoolLock
{
    bool* _pFlag;
public:
    BoolLock(bool* pFlag)
    {
        _pFlag = pFlag;
        *pFlag = true;
    }
    ~BoolLock()
    {
        *_pFlag = false;
    }
};

File Not Found
cujcexp1906alexandr

    struct CategoryInfo
    {
        int            CategoryID;
        AnsiString     CategoryName;
        int            Count;
    };
    static boost::shared_ptr<std::vector<boost::shared_ptr<CategoryInfo> > > GetCategories(int min)
    {
        boost::shared_ptr<TADOConnection> connect(new TADOConnection(0));
        connect->ConnectionString=
            "Server=.;Database=Northwind;Integrated Security=SSPI"
        ;
        connect->Open();
        boost::shared_ptr<TADODataSet> dataSet(new TADODataSet(0));
        dataSet->Connection=connect.get();
        dataSet->CommandText=
            "SELECT"
            "    p.CategoryID,"
            "    c.CategoryName,"
            "    Count(p.CategoryID) Count"
            "FROM Products p"
            "    INNER JOIN Categories c ON c.CategoryID = p.CategoryID"
            "GROUP BY p.CategoryID, c.CategoryName"
            "HAVING Count(p.CategoryID) >= @min"
            "ORDER BY c.CategoryName"
        ;
        TParameter* param=dataSet->Parameters->AddParameter();
        param->Name="@min";
        param->DataType=ftInteger;
        param->Value=min;
        dataSet->Open();
        boost::shared_ptr<std::vector<boost::shared_ptr<CategoryInfo> > > al(new std::vector<boost::shared_ptr<CategoryInfo> >);
        while(!dataSet->Eof)
        {
            boost::shared_ptr<CategoryInfo> ci(new CategoryInfo);
            ci->CategoryID   = dataSet->FieldValues["CategoryID"];
            ci->CategoryName = dataSet->FieldValues["CategoryName"];
            ci->Count        = dataSet->FieldValues["Count"];
            al->push_back(ci);
            dataSet->Next();
        }
        return al;
    }

Мда... печальное зрелище... без пузыря не разберёшся.

Это сделает их как раз только запутаннее и непонятнее и будем им грошь цена, после того как какой-нибудь студент, идущий за тобой, не поняв что там происходит, просто перепишет твой код на нормальный понятный язык. И будет, между прочим, прав.

IT>Для меня эталоном программы уже давно является не виртуозное владение указателями, свитчами и шаблонами, а ясный и понятный, хорошо оформленный и откомментированный код. Впрочем, может это я просто старею...

    Ref<I_Sensor> sensor=CreateObject<I_Sensor>(sensorClassName);
    ENFORCE(sensor, X_InvalidClassName)("Class Name =\"")(sensorClassName)("\"");//Исключение будет автоматом записано в лог 
    sensor->Name=sensorName;//Что грузить
    sensor->DataBase=dataBase;//От куда грузить
    ENFORCE(sensor->Load(), X_InvalidSensorName)("Class Name =\"")(sensorClassName)("\"; Sensor name =\"")(sensorName)("\"");
    //    Messge    : Class Name ="MyCoolSensorClass"; Sensor name ="MyCoolSensor"
    //См ниже

        ENFORCE(startPlugin, X_Terminate)("No start class");

!!!TERMINATED!!! 
    Exception : X_Terminate
    File      : W:\mlevel\kernel\C_Application.h
    Line      : 96
    Condition : startPlugin
    Messge    : No start class
    Date&Time : 03.07.2003 13:25:29

Compilers and tools expose the runtime's functionality and enable you to write code that benefits from this managed execution environment. Code that you develop with a language compiler that targets the runtime is called managed code; it benefits from features such as cross-language integration, cross-language exception handling, enhanced security, versioning and deployment support, a simplified model for component interaction, and debugging and profiling services.

static boost::shared_ptr<std::vector<boost::shared_ptr<CategoryInfo> > > GetCategories(int min)
{
    return DBManager<CategoryInfo>(
                "Server=.;Database=Northwind;Integrated Security=SSPI"
            ,
                "SELECT"
                "    p.CategoryID,"
                "    c.CategoryName,"
                "    Count(p.CategoryID) Count"
                "FROM Products p"
                "    INNER JOIN Categories c ON c.CategoryID = p.CategoryID"
                "GROUP BY p.CategoryID, c.CategoryName"
                "HAVING Count(p.CategoryID) >= @min"
                "ORDER BY c.CategoryName"
            ,    
                DBFields<CategoryInfo>()
                    (&CategoryInfo::CategoryID,        "CategoryID")
                    (&CategoryInfo::CategoryName,    "CategoryName")
                    (&CategoryInfo::Count,            "Count")
            ,
                DBParams()
                    ("@min", min)
        );
}

struct Variant
{
    operator int()const
    {
        return 123456;
    }
    operator std::string()const
    {
        return "Hello";
    }
};

template<class T>
struct SetFieldBase
{
    virtual void Set(T&, const Variant&)const=0;
};
template<class T, class U>
struct SetField
    :SetFieldBase<T>
{
    SetField(U T::* ptr)
        :ptr_(ptr)
    {}
    void Set(T& val, const Variant& var)const
    {
        val.*ptr_=var;
    }
private:
    U T::* ptr_;
};
template<class T, class U>
SetField<T, U> MakeSetField(U T::* ptr)
{
    return ptr;
}
struct CategoryInfo
{
    int            CategoryID;
    std::string CategoryName;
    int            Count;
};
int main()
{
    CategoryInfo info;
    const SetFieldBase<CategoryInfo>& setField1=MakeSetField(&CategoryInfo::CategoryID);
    const SetFieldBase<CategoryInfo>& setField2=MakeSetField(&CategoryInfo::CategoryName);
    const SetFieldBase<CategoryInfo>& setField3=MakeSetField(&CategoryInfo::Count);
    setField1.Set(info, Variant());
    setField2.Set(info, Variant());
    setField3.Set(info, Variant());
    return 0;
}

AVK>Activator.CreateInstance(Type.GetType("ClassName, assembly_name"));
AVK>

    Ref<I_Sensor> sensor=CreateObject<I_Sensor>(sensorClassName);

    I_Sensor sensor=(I_Sensor)Activator.CreateInstance(Type.GetType("ClassName, assembly_name"));

S>class TestA : public ddx::controller<TestA, Loki::NullType>, public CDialog
S>{
S>    typedef ddx::controller<derived_type, base_type> parent_t;
S>protected:
S>    typedef ddx::member<CString, IDC_SERVER, Ser, &DDX_CBString> m_Server;
S>    typedef ddx::member<CString, IDC_PROCESS_NAME, Ser, &DDX_Text> m_ProcessName;
S>    typedef ddx::members<TYPELIST_2(m_Server, m_ProcessName)> members_info;
S>public:
S>    TestA(CWnd *wnd) {}
S>    members_info ddxMembers;
S>};

S>class TestC : public ddx::controller<TestC, TestA>
S>{
S>    typedef ddx::controller<derived_type, base_type> parent_t;
S>protected:
S>    typedef ddx::members<Loki::NullType> members_info;
S>public:
S>    TestC(CWnd *wnd) : parent_t(wnd) {}
S>    members_info ddxMembers;
S>};

S>class TestB : public ddx::controller<TestB, TestC>
S>{
S>    typedef ddx::controller<derived_type, base_type> parent_t;
S>protected:
S>    typedef ddx::member<BOOL, IDC_CREATEMM, Ser, &DDX_Check> m_CreateMM;
S>    typedef ddx::members<TYPELIST_1(m_CreateMM)> members_info;
S>public:
S>    TestB(CWnd *wnd) : parent_t(wnd) {}
S>    members_info ddxMembers;
S>};
S>

[Serialize]
class TestA
{
    public TestA(CWnd wnd) {}
    public string m_Server;
    public string m_ProcessName;
};

[Serialize]
class TestC : TestA
{
    public TestC(CWnd wnd) : bsae(wnd)
};

...
    TestC с = new TestC(xxx);
    ... // Что-то тварим с объектом...
    // Это весь код необходимый для сериализации!
    MemoryStream ms = new MemoryStream(1024);
    BinaryFormatter bf = new BinaryFormatter();
    bf.Serialize(ms, ds);

AVK>[Serializable]
AVK>public class TestClass
AVK>{
AVK>    private string _someData;
    
AVK>    public TestClass(string someData)
AVK>    {
AVK>        _someData = someData;
AVK>    }
    
AVK>    public string SomeData
AVK>    {
AVK>        get { return _someData; }
AVK>    }
AVK>}
AVK>

AVK>Вот когда напишешь тогда и сравним. Результаты я думаю будут забавными

ГВ>>Т.е., рефлекшен реализует rtti.

...последствия его активного использования тем не менее остаются теми же самыми, что и при использовании C++-rtti

VD>Забавно ты расуждаешь. Тебе говорят, что это в некоторых случаях единственный виход, а в некоторых не еденственный но намного боле простой. А ты все криво, и криво. Этак я могу обвинить весь мир так как в нем нужно дышать воздухом и нельзя прыгать с небоскребов. Ну, право не серьезно.

ГВ>С точки зрения дизайна моей программы в данном случае rtti будет использован для задачи обработки внешних данных и, кстати, последствия в виде... ну я уже говорил, — никуда не денутся. И моя, кстати, негативная их оценка — тоже, несмотря на то, что это может оказаться единственным выходом.

VD>>Вот только ортодоксы типа Страуструпа всю малину портят.

VD>>Думаю, то чем ты говоришь скорее напоминает время между компиляциями.

VD>>Тут спору нет. Метаданные могли бы сослужить огромную службу. Но стандрат плюсов просто таки борится с этой идеей.

S>Проверял на всех ?

S>Есть, конечно, некоторая доля программистов, которые на бейсике еще быстрее чем на шарпе, писать будут

if(ia = ib)
 ...

if((ia = ib) != 0)
 ...

S>Там есть четкий приговор метаданным в твоем понимании

VD>>В общем, займись дотнетом и посмотрим на твои позиции чезе годик.

S>Противно Язык примитивный, рантам жирный, коммерчески применять (для нашей компании) рано...

template<typename T>
struct list_result
{
    typedef std::list<T> result_type;

    template<typename InputIterator>
    result_type operator()(InputIterator first, InputIterator last) const
    {
        result_type result;
        for(;first!=last;++first)
            result.push_back(*first);
        return result;
    }
};
float Add(int i, float f)
{
    return i+f;
}
float Sub(double i, float f)
{
    return i-f;
}
double Div(double i, float f)
{
    return i/f;
}
double Mul(double i, int f)
{
    return i*f;
}
int main()
{
    namespace lm=boost::lambda;
    boost::signal<float(float,float), list_result<float> > sig;
    sig.connect(&Add);
    sig.connect(&Sub);
    sig.connect(&Div);
    sig.connect(&Mul);

    std::list<float> test=sig(10, 20);
    for_each(test, std::cout<<lm::_1<<"\n");

    return 0;
}

30
-10
0.5
200

using System;
class SignalsTest
{
    delegate double op(double i, double f);

    static double Add(double i, double f){ return i + f; }
    static double Sub(double i, double f){ return i - f; }
    static double Div(double i, double f){ return i / f; }
    static double Mul(double i, double f){ return i * f; }

    static double[] CallAll(op[] opers, double i, double f)
    {
        double[] res = new double[opers.Length];
        for(int k = 0; k < opers.Length; k++)
            res[k] = opers[k](10, 20);
        return res;
    }

    static void PrintDouble(double[] ary)
    {
        foreach(double val in ary)
            Console.WriteLine(val);
    }

    static void Main(string[] args)
    {
        op[] opers = new op[4] 
        {
            new op(Add),
            new op(Sub),
            new op(Div),
            new op(Mul)
        };

        PrintDouble(CallAll(opers, 10, 20));

        Console.ReadLine();
    }
}