Хотя исправление функции изменения так, что она вызывается для выбора, а не для опции, важно, ваша проблема - сама выбранная опция по умолчанию. Как вы упомянули, если им нужен первый вариант, им нужно выбрать что-то еще, чтобы вызвать функцию изменения.
Я бы порекомендовал добавить «пустую» опцию в качестве первой опции и установить ее как выбранную.
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);
Это относится, как разрешены перегруженные методы.
Эффективно (упрощенный несколько), компилятор сначала смотрит на заявленный тип выражения (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# приняли неправильное решение.
Хорошо, таким образом,
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() + ")");
}
Это было большим вопросом.
Все ответы могут быть найдены здесь: http://msdn.microsoft.com/en-us/library/6fawty39 (По сравнению с 80) .aspx
Суть его - это:
... компилятор C# сначала попытается выполнить вызов, совместимый с версиями [functionName], объявленного первоначально на [производный класс]. Переопределенные методы не рассматривают, как объявлено на классе, они - новые реализации метода, объявленного на базовом классе. Только если компилятор C# не может соответствовать вызову метода исходного метода для [Производный класс] будет он пытаться соответствовать вызову к переопределенному методу с тем же именем и совместимыми параметрами.
Таким образом, потому что у Вас есть новая Печать метода (я i) на производном классе, который соответствует аргументу "c", (потому что c реализует I), тот метод имеет приоритет по методу "переопределения".
Когда Вы отмечаете метод как "новый", они и считаются реализованными на производном классе и Печати (C c), метод более тесно соответствует параметру "c", таким образом, это имеет приоритет.
Это - по крайней мере, так же вопрос о том, как перегрузка метода работает в C#. Я думаю, что Вы выделили интересную ситуацию здесь...
В первом случае (использующий new
ключевое слово на методе), компилятор решает использовать Print
перегрузка метода с параметром типа C, потому что это - тип, точно эквивалентна тому из переданного параметра (т.е. никакое неявное преобразование не требуется), тогда как неявное преобразование в интерфейс, я требовался бы, если бы компилятор должен был выбрать Print
метод, который берет аргумент типа I - другими словами, он выбирает более "очевидную" перегрузку метода.
Во втором случае (использующий override
ключевое слово на методе), компилятор решает использовать перегрузку Print
с параметром типа I, потому что, хотя Вы переопределяете Print(C c)
перегрузка метода в классе B, это эффективно определяется в родительском классе A, делая Print(I i)
перегрузка метода на самом деле перегрузка высшего уровня и поэтому самая прямая, т.е. первая компилятор находит.
Надо надеяться, это поможет Вам понять. Сообщите мне, должен ли я прояснить какие-либо мысли далее...
Примечание: Если я неправ относительно высказывания, что компилятор делает эти вещи, то исправьте меня, хотя это имеет мало значения ради аргумента, является ли это компилятором или CLR/JIT, это казалось бы.