Вот такие конструкции

public static @*( a:Point2DF, b:float):Point2DF{...}

В C# только видит как static Point2DF.op_Multiply, а записать через знак * непозволяет
к чему бы это ?

Здравствуйте, chudo19, Вы писали:

C>Вот такие конструкции
C>public static @*( a:Point2DF, b:float):Point2DF{...}
C>В C# только видит как static Point2DF.op_Multiply, а записать через знак * непозволяет
C>к чему бы это ?

Хорошо бы видеть полный тест.

Здравствуйте, VladD2, Вы писали:

VD>Хорошо бы видеть полный тест.

Полный текст чего ? класса ?

Здравствуйте, <Аноним>, Вы писали:

А>Полный текст чего ? класса ?

Теста деморстрирует проблему. Так чтобы его можно было скомпилировать и запустить.

Здравствуйте, VladD2, Вы писали:


VD>Теста деморстрирует проблему. Так чтобы его можно было скомпилировать и запустить.

Ну вот пример , ничего особеного собсно

using System;
using System.Collections;
using System.Collections.Generic;
using System.Drawing;
namespace MyMath
{
    

    public struct Point2DF
    {
         public mutable X:float;
        public mutable Y:float;

        public this( x:float,  y:float)
        {
            X = x;
            Y = y;
        }
        public this( p:Point)
        {

            X = p.X;
            Y = p.Y; ;
        }
        public this( p:PointF)
        {

            X = p.X;
            Y = p.Y; ;
        }
        public this( p:SizeF)
        {

            X = p.Width;
            Y = p.Height ;
        }
       





        public static op_Explicit /*explicit */ ( m:Point2DF):Point
        {
            Point(m.X:>int, m.Y:>int);
        }
        public static op_Implicit  ( m:Point2DF):PointF
        {
              PointF(m.X, m.Y);
        }



        public static op_Implicit  ( m:Point):Point2DF
        {
           Point2DF(m.X, m.Y);
        }

        public static op_Explicit  ( m:PointF):Point2DF
        {
            Point2DF(m.X, m.Y);
        }

        public static   @==( a:Point2DF,  b:Point2DF):bool
        {
            a.X == b.X && a.Y == b.Y;
        }

        public static  @!=( a:Point2DF,  b:Point2DF):bool
        {
           !(a == b);
        }
        public override  Equals( o:object):bool
        {
            if (!(o is Point2DF))
            {    false;}
            else{
            def p = o:>Point2DF;


             X == p.X && Y == p.Y;
            }
        }


        public static  @-( a:Point2DF,  b:Point2DF):Point2DF
        {
            Point2DF(a.X - b.X, a.Y - b.Y);
        }
        public static  @+( a:Point2DF,  b:Point2DF):Point2DF
        {
             Point2DF(a.X + b.X, a.Y + b.Y);
        }



        public static  @*( a:Point2DF,  b:int):Point2DF
        {
             Point2DF(a.X * b, a.Y * b);
        }

        public static  @*( a:Point2DF,  b:float):Point2DF
        {
            Point2DF(a.X * b, a.Y * b);
        }
        public static  @*( b:float,  a:Point2DF):Point2DF
        {
             Point2DF(a.X * b, a.Y * b);
        }



    }
}

Здравствуйте, chudo19, Вы писали:

VD>>Теста деморстрирует проблему. Так чтобы его можно было скомпилировать и запустить.
C>Ну вот пример , ничего особеного собсно

Помнится мне, такая проблема была. В последней svn-версии вроде все ок. Так что забирай last version

Можно по коду маленько конструктивной критики?

    [Record] // это вместо конструктора (***)
C>  public struct Point2DF
C>  {
C>    public mutable X:float;
C>    public mutable Y:float;

        // конструктор (***) - использование в место него макроса Record - это стандартная практика
C>        public this( x:float,  y:float)
C>        {
C>            X = x;
C>            Y = y;
C>        }

C>//        public static op_Explicit /*explicit */ ( m:Point2DF):Point
C>        public static @:> ( m:Point2DF):Point
C>        {
C>            Point(m.X:>int, m.Y:>int);
C>        }
C>//        public static op_Implicit  ( m:Point2DF):PointF
C>        public static @: ( m:Point2DF):PointF
C>        {
C>              PointF(m.X, m.Y);
C>        }

Почему-то разработчики .NET часто (например, в уже упомиавшейся тут структуре Point) делают так же, как это сделал ты. Т.е. "!=" выражают через "==", а Equals пишут заново
Почему бы просто не сделать что-нибудь вроде:

C>        public static   @==( a:Point2DF,  b:Point2DF):bool
C>        {
C>            a.X == b.X && a.Y == b.Y;
C>        }

C>        public static  @!=( a:Point2DF,  b:Point2DF):bool
C>        {
C>           !(a == b);
C>        }

C>        public override  Equals( o:object):bool
C>        {
                o is Point2DF && this == (o:>Point2DF);
C>//            if (!(o is Point2DF))
C>//            {    false;}
C>//            else{
C>//            def p = o:>Point2DF;
C>//             X == p.X && Y == p.Y;
C>//            }
C>        }
C>    }
C>}

Что до меня, то я бы использовал макрос OverrideObjectEquals:

        public static @==( a:Point2DF,  b:Point2DF):bool
        {
            a.X == b.X && a.Y == b.Y;
        }

        public static @!=( a:Point2DF,  b:Point2DF):bool
        {
           !(a == b);
        }
        [Nemerle.OverrideObjectEquals]
        public Equals(p : Point2DF) : bool
        {
            this == p;
        }