Как метод, скрывающий работы в C#? (Часть вторая)

Хотя исправление функции изменения так, что она вызывается для выбора, а не для опции, важно, ваша проблема - сама выбранная опция по умолчанию. Как вы упомянули, если им нужен первый вариант, им нужно выбрать что-то еще, чтобы вызвать функцию изменения.

Я бы порекомендовал добавить «пустую» опцию в качестве первой опции и установить ее как выбранную.

var  $select_ex = $("#select_ex");  

.done(result){
      $select_ex.empty().append("<option value='0'>Select Your Ex Below!</option>");
      $.each(result.data,function (){
        $select_ex.append("<option value...... ></option>");
      });

      $select_ex.val("0");
    }

    $select_ex.change(function_2);
13
задан Groo 31 December 2009 в 08:30
поделиться

4 ответа

Это относится, как разрешены перегруженные методы.

Эффективно (упрощенный несколько), компилятор сначала смотрит на заявленный тип выражения (B) в этом случае и ищет методы кандидата, которые сначала объявляются в том типе. Если существуют какие-либо методы, которые являются соответствующими (т.е. где все аргументы могут быть преобразованы в типы параметра метода), затем, это не смотрит ни на какие родительские типы. Это означает, что переопределенные методы, где начальное объявление находится в родительском типе, не получают взгляд - в том, если существуют какие-либо "недавно заявленные" соответствующие методы в производном типе.

Вот немного более простой пример:

using System;

class Base
{
    public virtual void Foo(int x)
    {
        Console.WriteLine("Base.Foo(int)");
    }
}

class Derived : Base
{
    public override void Foo(int x)
    {
        Console.WriteLine("Derived.Foo(int)");
    }

    public void Foo(double d)
    {
        Console.WriteLine("Derived.Foo(double)");
    }
}

class Test
{
    static void Main()
    {
        Derived d = new Derived();
        d.Foo(10);
    }
}

Это печатает Derived.Foo(double) - даже при том, что компилятор знает, что существует метод сопоставления с параметром типа int, и аргументом является тип int, и преобразование из int кому: int "лучше", чем преобразование из int кому: double, факт это только Foo(double) метод первоначально объявляется в Derived означает, что компилятор игнорирует Foo(int).

Это - очень удивительный IMO. Я вижу, почему это имело бы место если Derived не переопределял Foo - иначе представление нового, более определенного, метода в базовом классе могло неожиданно изменить поведение - но ясно Derived здесь знает о Base.Foo(int) поскольку это переопределяет его. Это - один из (относительно немногие) точки, где я полагаю, что разработчики C# приняли неправильное решение.

8
ответ дан 2 December 2019 в 01:21
поделиться

Хорошо, таким образом,

    public new void Print(C c)
    {
        Console.WriteLine("B:C(" + c.A() + "," + c.B() + ")");
    }

    public void Print(I i)
    {
        Console.WriteLine("B:I(" + i.A() + ")");
    }

Это объявляет новый метод для печати. Теперь, потому что B наследовался A, Вы просто называете новый метод дважды. Когда Вы сверхъязь метод, это затем изменяет сигнатуру метода при призыве к A, но когда Вы называете подпись B, затем это имеет свою собственную сигнатуру метода.

Я не уверен, объясняю ли я ясный но хороший вопрос.

новое использование:

A и B получают ту же реализацию Метода печати.

использование переопределения:

Другой сигнатуры метода к B как, Вы не изменили сигнатуру метода в B только в A.

с помощью нового это в основном игнорирует это:

    public void Print(I i)
    {
        Console.WriteLine("B:I(" + i.A() + ")");
    }
1
ответ дан 2 December 2019 в 01:21
поделиться

Это было большим вопросом.
Все ответы могут быть найдены здесь: http://msdn.microsoft.com/en-us/library/6fawty39 (По сравнению с 80) .aspx

Суть его - это:

... компилятор C# сначала попытается выполнить вызов, совместимый с версиями [functionName], объявленного первоначально на [производный класс]. Переопределенные методы не рассматривают, как объявлено на классе, они - новые реализации метода, объявленного на базовом классе. Только если компилятор C# не может соответствовать вызову метода исходного метода для [Производный класс] будет он пытаться соответствовать вызову к переопределенному методу с тем же именем и совместимыми параметрами.

Таким образом, потому что у Вас есть новая Печать метода (я i) на производном классе, который соответствует аргументу "c", (потому что c реализует I), тот метод имеет приоритет по методу "переопределения".

Когда Вы отмечаете метод как "новый", они и считаются реализованными на производном классе и Печати (C c), метод более тесно соответствует параметру "c", таким образом, это имеет приоритет.

1
ответ дан 2 December 2019 в 01:21
поделиться

Это - по крайней мере, так же вопрос о том, как перегрузка метода работает в C#. Я думаю, что Вы выделили интересную ситуацию здесь...

В первом случае (использующий new ключевое слово на методе), компилятор решает использовать Print перегрузка метода с параметром типа C, потому что это - тип, точно эквивалентна тому из переданного параметра (т.е. никакое неявное преобразование не требуется), тогда как неявное преобразование в интерфейс, я требовался бы, если бы компилятор должен был выбрать Print метод, который берет аргумент типа I - другими словами, он выбирает более "очевидную" перегрузку метода.

Во втором случае (использующий override ключевое слово на методе), компилятор решает использовать перегрузку Print с параметром типа I, потому что, хотя Вы переопределяете Print(C c) перегрузка метода в классе B, это эффективно определяется в родительском классе A, делая Print(I i) перегрузка метода на самом деле перегрузка высшего уровня и поэтому самая прямая, т.е. первая компилятор находит.

Надо надеяться, это поможет Вам понять. Сообщите мне, должен ли я прояснить какие-либо мысли далее...

Примечание: Если я неправ относительно высказывания, что компилятор делает эти вещи, то исправьте меня, хотя это имеет мало значения ради аргумента, является ли это компилятором или CLR/JIT, это казалось бы.

0
ответ дан 2 December 2019 в 01:21
поделиться
Другие вопросы по тегам:

Похожие вопросы: