Как я создаю делегата к свойству.NET?
Я бы сделал компонент (или функцию, если это кажется более подходящим) для визуализации отдельной монеты.
Вы можете сделать компонент <Coin> и передать ему необходимые данные в виде реквизита:
render() {
return (
<div className='purse'>
{this.state.lists.map((coin, index) => <Coin data={coin} index={index} key={coin.CoinInfo.Id} />)}
</div>
);
}
Или просто переместить рендеринг монеты в новую функцию:
renderCoin(coin, index) {
return <ul className='coin-containers' key={coin.CoinInfo.Id}>
<li><img className='coinImages' src={`${API_BASE_IMAGE}${coin.CoinInfo.ImageUrl}`} alt={coin.CoinInfo.FullName}/>
</li>
<li>{index + 1}</li>
<li>{coin.CoinInfo.FullName}</li>
<li className='ticker'>{coin.CoinInfo.Name}</li>
<li>{coin.DISPLAY.USD.PRICE}</li>
<li>{coin.DISPLAY.USD.SUPPLY}</li>
<li>{coin.DISPLAY.USD.MKTCAP}</li>
<li>24HR</li>
<li>{coin.DISPLAY.USD.CHANGEPCT24HOUR}%</li>
</ul>;
}
render() {
return (
<div className='purse'>
{this.state.lists.map((coin, index) => this.renderCoin(coin, index))}
</div>
);
}
3 ответа
Ре использование задач AddressOf - если Вы знаете имя опоры во время компиляции, Вы можете (в C#, по крайней мере) используют скоро-метод / лямбда:
Test t = delegate { return e.PropertyName; }; // C# 2.0
Test t = () => e.PropertyName; // C# 3.0
Я не эксперт VB, но отражатель утверждает, что это совпадает с:
Dim t As Test = Function
Return e.PropertyName
End Function
Это работает?
Исходный ответ:
Вы создаете делегатов к свойствам с Delegate.CreateDelegate; это может быть открыто для любого экземпляра типа, фиксированных для единственного экземпляра - и может быть для метода считывания или метода set; я дам пример в C#...
using System;
using System.Reflection;
class Foo
{
public string Bar { get; set; }
}
class Program
{
static void Main()
{
PropertyInfo prop = typeof(Foo).GetProperty("Bar");
Foo foo = new Foo();
// create an open "getter" delegate
Func<Foo, string> getForAnyFoo = (Func<Foo, string>)
Delegate.CreateDelegate(typeof(Func<Foo, string>), null,
prop.GetGetMethod());
Func<string> getForFixedFoo = (Func<string>)
Delegate.CreateDelegate(typeof(Func<string>), foo,
prop.GetGetMethod());
Action<Foo,string> setForAnyFoo = (Action<Foo,string>)
Delegate.CreateDelegate(typeof(Action<Foo, string>), null,
prop.GetSetMethod());
Action<string> setForFixedFoo = (Action<string>)
Delegate.CreateDelegate(typeof(Action<string>), foo,
prop.GetSetMethod());
setForAnyFoo(foo, "abc");
Console.WriteLine(getForAnyFoo(foo));
setForFixedFoo("def");
Console.WriteLine(getForFixedFoo());
}
}
Вот пример C#, но все типы являются тем же:
Сначала создайте интерфейс (делегат). Помните, метод, который Вы присоединяете к своему делегату, должен возвратить тот же тип и взять те же параметры в качестве объявления Вашего делегата. Не определяйте своего делегата в том же объеме как Ваше событие.
public delegate void delgJournalBaseModified();
Сделайте событие на основе делегата:
public static class JournalBase {
public static event delgJournalBaseModified evntJournalModified;
};
Определите метод, который может быть связан с Вашим событием, которое имеет интерфейс, идентичный делегату.
void UpdateEntryList()
{
}
Свяжите метод с событием. Метод называют, когда событие запущено. Можно связать как много методов с событием. Я не знаю предела. Это - вероятно, что-то сумасшедшее.
JournalBase.evntJournalModified += new delgJournalBaseModified(UpdateEntryList);
То, что происходит, вот метод, добавляется как обратный вызов для Вашего события. Когда событие будет запущено, Ваш метод (методы) назовут.
Затем мы делаем метод, который запустит событие при вызове:
public static class JournalBase {
public static void JournalBase_Modified()
{
if (evntJournalModified != null)
evntJournalModified();
}
};
Затем Вы просто называете метод - JournalBase_Modified () - где-нибудь в Вашем коде и всех методах, связанных с Вашим событием, называют также, один за другим.
Вот версия C # /. NET 2.0 Ответ Марка Гравелла :
using System;
using System.Reflection;
class Program
{
private delegate void SetValue<T>(T value);
private delegate T GetValue<T>();
private class Foo
{
private string _bar;
public string Bar
{
get { return _bar; }
set { _bar = value; }
}
}
static void Main()
{
Foo foo = new Foo();
Type type = typeof (Foo);
PropertyInfo property = type.GetProperty("Bar");
// setter
MethodInfo methodInfo = property.GetSetMethod();
SetValue<string> setValue =
(SetValue<string>) Delegate.CreateDelegate(typeof (SetValue<string>), foo, methodInfo);
setValue("abc");
// getter
methodInfo = property.GetGetMethod();
GetValue<string> getValue =
(GetValue<string>) Delegate.CreateDelegate(typeof (GetValue<string>), foo, methodInfo);
string myValue = getValue();
// output results
Console.WriteLine(myValue);
}
}
Опять же, « Delegate.CreateDelegate » является основным к этому примеру.