Согласно Документам Царства (выделено мной):
Операторы сравнения ==, < =, & lt ;,> =,>,! = И BETWEEN поддерживаются для типов свойств Int, Int8, Int16, Int32, Int64, Float, Double и Date
blockquote>Таким образом, должно работать следующее:
let date = Date() todayEvent = realm.objects(Events.self) .filter("date == %@", date) .sorted(byKeyPath: "venue") // sorted in ascending order by default
Я знаю, что это древний вопрос, но, черт возьми, я нашел его и полагаю, что другие тоже могут. Я пытаюсь решить связанную с этим проблему и могу кое-что узнать.
Вы упомянули WeakEventHandler Дастина Кэмпбелла - он действительно не может работать с анонимными методами по замыслу. Я пытался подстроить что-то вместе, когда я понял, что а) в 99% случаев мне понадобится что-то вроде этого, его исходное решение будет более безопасным, и б) в тех немногих случаях, когда мне нужно (примечание: иметь to, а не «хотите, потому что лямбды намного красивее и лаконичнее»), это можно заставить работать, если вы немного поумнеете.
Ваш пример выглядит как разовый случай, когда небольшие хитрости могут привести к довольно краткому решению.
public static class Linker {
public static void Link(Publisher publisher, Control subscriber) {
// anonymous method references the subscriber only through weak
// references,so its existance doesn't interfere with garbage collection
var subscriber_weak_ref = new WeakReference(subscriber);
// this instance variable will stay in memory as long as the anonymous
// method holds a reference to it we declare and initialize it to
// reserve the memory (also, compiler complains about uninitialized
// variable otherwise)
EventHandler<ValueEventArgs<bool>> handler = null;
// when the handler is created it will grab references to the local
// variables used within, keeping them in memory after the function
// scope ends
handler = delegate(object sender, ValueEventArgs<bool> e) {
var subscriber_strong_ref = subscriber_weak_ref.Target as Control;
if (subscriber_strong_ref != null)
subscriber_strong_ref.Enabled = e.Value;
else {
// unsubscribing the delegate from within itself is risky, but
// because only one instance exists and nobody else has a
// reference to it we can do this
((Publisher)sender).EnabledChanged -= handler;
// by assigning the original instance variable pointer to null
// we make sure that nothing else references the anonymous
// method and it can be collected. After this, the weak
// reference and the handler pointer itselfwill be eligible for
// collection as well.
handler = null;
}
};
publisher.EnabledChanged += handler;
}
}
По слухам, шаблон WPF Weak Event связан с большими накладными расходами, поэтому в данной конкретной ситуации я бы не стал его использовать. Кроме того, ссылка на основную библиотеку WPF в приложении WinForm также кажется немного сложной.
Если Вы сохраняете ссылку на анонимного делегата и затем удаляете ее, когда средства управления удалены из формы, которая должна позволить и средствам управления и анонимным делегатам быть собранными "мусор".
Так что-то вроде этого:
public static class Linker
{
//(Non-lambda version, I'm not comfortable with lambdas:)
public static EventHandler<ValueEventArgs<bool>> Link(Publisher publisher, Control subscriber)
{
EventHandler<ValueEventArgs<bool>> handler = delegate(object sender, ValueEventArgs<bool> e)
{
subscriber.Enabled = e.Value;
};
publisher.EnabledChanged += handler;
return handler;
}
public static void UnLink(Publisher publisher, EventHandler<ValueEventArgs<bool>> handler)
{
publisher.EnabledChanged -= handler;
}
}
Посмотрите Отказываются от подписки анонимный метод в C# для примера удаления делегатов.
Некоторый пример кода, который я сделал недавно, на основе WeakReference:
// strongly typed weak reference
public class WeakReference<T> : WeakReference
where T : class
{
public WeakReference(T target)
: base(target)
{ }
public WeakReference(T target, bool trackResurrection)
: base(target, trackResurrection)
{ }
public new T Target
{
get { return base.Target as T; }
set { base.Target = value; }
}
}
// weak referenced generic event handler
public class WeakEventHandler<TEventArgs> : WeakReference<EventHandler<TEventArgs>>
where TEventArgs : EventArgs
{
public WeakEventHandler(EventHandler<TEventArgs> target)
: base(target)
{ }
protected void Invoke(object sender, TEventArgs e)
{
if (Target != null)
{
Target(sender, e);
}
}
public static implicit operator EventHandler<TEventArgs>(WeakEventHandler<TEventArgs> weakEventHandler)
{
if (weakEventHandler != null)
{
if (weakEventHandler.IsAlive)
{
return weakEventHandler.Invoke;
}
}
return null;
}
}
// weak reference common event handler
public class WeakEventHandler : WeakReference<EventHandler>
{
public WeakEventHandler(EventHandler target)
: base(target)
{ }
protected void Invoke(object sender, EventArgs e)
{
if (Target != null)
{
Target(sender, e);
}
}
public static implicit operator EventHandler(WeakEventHandler weakEventHandler)
{
if (weakEventHandler != null)
{
if (weakEventHandler.IsAlive)
{
return weakEventHandler.Invoke;
}
}
return null;
}
}
// observable class, fires events
public class Observable
{
public Observable() { Console.WriteLine("new Observable()"); }
~Observable() { Console.WriteLine("~Observable()"); }
public event EventHandler OnChange;
protected virtual void DoOnChange()
{
EventHandler handler = OnChange;
if (handler != null)
{
Console.WriteLine("DoOnChange()");
handler(this, EventArgs.Empty);
}
}
public void Change()
{
DoOnChange();
}
}
// observer, event listener
public class Observer
{
public Observer() { Console.WriteLine("new Observer()"); }
~Observer() { Console.WriteLine("~Observer()"); }
public void OnChange(object sender, EventArgs e)
{
Console.WriteLine("-> Observer.OnChange({0}, {1})", sender, e);
}
}
// sample usage and test code
public static class Program
{
static void Main()
{
Observable subject = new Observable();
Observer watcher = new Observer();
Console.WriteLine("subscribe new WeakEventHandler()\n");
subject.OnChange += new WeakEventHandler(watcher.OnChange);
subject.Change();
Console.WriteLine("\nObserver = null, GC");
watcher = null;
GC.Collect(0, GCCollectionMode.Forced);
GC.WaitForPendingFinalizers();
subject.Change();
if (Debugger.IsAttached)
{
Console.Write("Press any key to continue . . . ");
Console.ReadKey(true);
}
}
}
Создает следующий вывод:
new Observable()
new Observer()
subscribe new WeakEventHandler()
DoOnChange()
-> Observer.OnChange(ConsoleApplication4.Observable, System.EventArgs)
Observer = null, GC
~Observer()
DoOnChange()
~Observable()
Press any key to continue . . .
(Обратите внимание, что отмена подписки (- =) не работает)
Опираясь на ответ Егора , я хотел попробовать создать версию, в которой мне не нужно было заранее определять , какое событие я хочу для присоединения к.
Мне удалось заставить его работать только с универсальными обработчиками событий: для «стандартных» обработчиков событий (например, FormClosingEventHandler) это немного сложно, потому что у вас не может быть ограничения типа где T: делегат
(если ваше имя не оканчивается на Pony ).
private static void SetAnyGenericHandler<S, T>(
Action<EventHandler<T>> add, //to add event listener to publisher
Action<EventHandler<T>> remove, //to remove event listener from publisher
S subscriber, //ref to subscriber (to pass to consume)
Action<S, T> consume) //called when event is raised*
where T : EventArgs
where S : class
{
var subscriber_weak_ref = new WeakReference(subscriber);
EventHandler<T> handler = null;
handler = delegate(object sender, T e)
{
var subscriber_strong_ref = subscriber_weak_ref.Target as S;
if(subscriber_strong_ref != null)
{
Console.WriteLine("New event received by subscriber");
consume(subscriber_strong_ref, e);
}
else
{
remove(handler);
handler = null;
}
};
add(handler);
}
(* Я пробовал EventHandler
, но вызывающий код становится некрасивым, потому что вы должны привести s к подписчику в лямбда-выражении потребления.)
Пример кода вызова, взятый из примера выше:
SetAnyGenericHandler(
h => publisher.EnabledChanged += h,
h => publisher.EnabledChanged -= h,
subscriber,
(Subscriber s, ValueEventArgs<bool> e) => s.Enabled = e.Value);
Или, если вы предпочитаете
SetAnyGenericHandler<Subscriber, ValueEventArgs<bool>>(
h => publisher.EnabledChanged += h,
h => publisher.EnabledChanged -= h,
subscriber,
(s, e) => s.Enabled = e.Value);
Было бы неплохо иметь возможность передать событие как просто один параметр, но вы можете 't получить доступ к добавлению / удалению из события точно так же, как вы можете получить доступ к get / set из свойства (я думаю, без всяких мерзких отражений).