Алексей Павлов

Вам не нужно делать второй конвертер, а настроить тот, чтобы возвращал нужное значение - возвращать Visibility.Collapsed при истине и Visibility.Visible при лжи.

public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
    if ((bool)value)
    {
        return parameter != null ? Visibility.Collapsed : Visibility.Hidden;
    }
    return Visibility.Visible;
}

А если нужно именно проверять несколько различных проверок у одного элемента, то используйте MultiBinding. Я написал об этом тут.

В вашем случае, подойдёт создание специального кастомного конвертера, который сделает и из числа в строку, и потом строку обработает.

Другой вариант - MultiBinding. Создаётся специальный мультиконвертер, в который указывается несколько обычных биндингов. Но они обрабатываются параллельно, поэтому, если нужно вначале делать первый конвертер, а потом использовать его результат в другом конвертере, то так не получится, все данные обрабатываются в мультиконвертере.

Но мультибиндинг работает в WPF, а в Silverlight нет. Но для Silverlight есть workaround: www.codeproject.com/Articles/286171/MultiBinding-i...

Вот пример мультиконвертера, который берёт несколько bool, и проверяет, все ли они истинны (или ложны - можно выбрать).

Использование конвертера:

xmlns:converters="clr-namespace:MyProject.Converters"

<CheckBox x:Name="Checkbox1" Content="Чекбокс 1"/>
<CheckBox x:Name="Checkbox2" Content="Чекбокс 2"/>
<ToggleButton Content="Кнопка">
    <ToggleButton.IsEnabled>
        <MultiBinding Converter="{converters:BooleanMultiConverter Type=AllTrue}">
            <Binding Path="IsChecked" ElementName="Checkbox1"/>
            <Binding Path="IsChecked" ElementName="Checkbox2"/>
        </MultiBinding>
    </ToggleButton.IsEnabled>
</ToggleButton>

Сам конвертер:

using System;
using System.Linq;
using System.Windows;
using System.Windows.Data;
using System.Windows.Markup;

namespace MyProject.Converters
{
    public class BooleanMultiConverter : MarkupExtension, IMultiValueConverter
    {
        /// <summary>
        /// Перечисление типа конвертера
        /// </summary>
        public enum Types
        {
            AllTrue,
            AllFalse,
            AnyTrue,
            AnyFalse,
        }

        /// <summary>
        /// Тип конвертера, по умолчанию - AllTrue
        /// </summary>
        public Types Type { get; set; }

        public object Convert(object[] values, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {
            switch (Type)
            {
                case Types.AllTrue:
                    return values.All(v => (bool)v);
                case Types.AllFalse:
                    return values.All(v => !(bool)v);
                case Types.AnyTrue:
                    return values.Any(v => (bool)v);
                case Types.AnyFalse:
                    return values.Any(v => !(bool)v);
                default:
                    throw new InvalidOperationException();
            }
        }

        public object[] ConvertBack(object value, Type[] targetTypes, object parameter, System.Globalization.CultureInfo culture)
        {
            return new[] { DependencyProperty.UnsetValue };
        }

        #region MarkupExtension

        public BooleanMultiConverter()
        {
        }

        /// <summary>
        /// Отображать конвертер в списке
        /// </summary>
        public override object ProvideValue(IServiceProvider serviceProvider)
        {
            return this;
        }

        #endregion
    }
}

MarkupExtension используется, чтобы не создавать кучу конвертеров в ресурсах

Нужно просто поставить привязку с командой у вашей вьюмодели. Вы ведь используете MVVM?

Гораздо удобнее использовать не создавать вручную ICommand, а сделать класс, реализующий этот интерфейс. Обычно его называют DelegateCommand (классы указаны ниже).

И дальше во вьюмодели создаёте свойство для команды и привязывайте то место, где нужна команда, к созданной команде во вьюмодели.

#region Свойства

public ObservableCollection<MyClass> Collection { get; set; } = new ObservableCollection<MyClass>
{
    new MyClass { Name = "Иванов Иван" },
    new MyClass { Name = "Петров Пётр" },
    new MyClass { Name = "Сидоров Сидор" },
};
public MyClass SelectedCollection { get; set; };

#endregion

#region Команды

private ActionCommand _myCommand;
public ActionCommand MyCommand => _myCommand ?? (_myCommand = new ActionCommand(MyMethod));

private DelegateCommand<MyClass> _myDelegateCommand;
public DelegateCommand<MyClass> MyDelegateCommand => _myDelegateCommand ?? (_myDelegateCommand = new DelegateCommand<MyClass>(MyMethod2, item => item != null);

private void MyMethod()
{
    // обработка команды
}

private void MyMethod2(MyClass item)
{
    // обработка команды
}

#endregion

<ListBox ItemsSource="{Binding Collection}" SelectedItem="{Binding SelectedItem}"/>
<Button Command="{Binding MyCommand}" Content="Команда 1"/>
<Button Command="{Binding MyDelegateCommand}" CommandParameter="{Binding SelectedItem}" Content="Команда 2"/>

Если нужна команда не на событие Сlick, а на любое другое событие (как вы говорите, на DoubleClick), то нужно сделать добавить референс на System.Windows.Interactivity и указать триггер на событие:

xmlns:i="clr-namespace:System.Windows.Interactivity;assembly=System.Windows.Interactivity"

<ListBox ItemsSource="{Binding Collection}" SelectedItem="{Binding SelectedItemc}" DisplayMemberPath="Name">
    <i:Interaction.Triggers>
        <i:EventTrigger EventName="MouseDoubleClick">
            <i:InvokeCommandAction Command="{Binding MyDelegateCommand}" CommandParameter="{Binding SelectedItem}" />
        </i:EventTrigger>
    </i:Interaction.Triggers>
</ListBox>

Класс DelegateCommand - команда с параметром, и класс ActionCommand - команда без параметра. Нешаблонный класс DelegateCommand используется реже (я вообще не припомню, чтобы его использовал).

public class DelegateCommand<T> : ICommand
{
    #region Private fields

    private readonly Action<T> _execute;
    private readonly Func<T, bool> _canExecute;

    #endregion

    #region Constructors

    public DelegateCommand(Action<T> execute, Func<T, bool> canExecute = null)
    {
        _execute = execute;
        _canExecute = canExecute;
    }

    #endregion

    #region DelegateCommand

    public void Execute(T parameter)
    {
        var handler = _execute;
        if (handler != null)
        {
            handler(parameter);
        }
    }

    public bool CanExecute(T parameter)
    {
        var handler = _canExecute;
        return handler == null || handler(parameter);
    }

    public event EventHandler CanExecuteChanged
    {
        add { CommandManager.RequerySuggested += value; }
        remove { CommandManager.RequerySuggested -= value; }
    }

    #endregion

    #region ICommand

    void ICommand.Execute(object parameter)
    {
        Execute((T)parameter);
    }

    bool ICommand.CanExecute(object parameter)
    {
        return CanExecute((T)parameter);
    }

    #endregion
}

public class DelegateCommand : DelegateCommand<object>
{
    public DelegateCommand(Action<object> execute, Func<object, bool> canExecute = null)
        : base(execute, canExecute)
    {
    }
}

public class ActionCommand : DelegateCommand<object>, ICommand
{
    #region Private fields

    private readonly Action _action;
    private readonly Func<bool> _canExecute;

    #endregion

    #region Constructors

    public ActionCommand(Action action, Func<bool> canExecute = null)
        : base(null, null)
    {
        _action = action;
        _canExecute = canExecute;
    }

    #endregion

    #region ActionCommand

    public void Execute()
    {
        var handler = _action;
        if (handler != null)
        {
            handler();
        }
    }

    public bool CanExecute()
    {
        var handler = _canExecute;
        return handler == null || handler();
    }

    #endregion

    #region ICommand

    void ICommand.Execute(object parameter)
    {
        Execute();
    }

    bool ICommand.CanExecute(object parameter)
    {
        return CanExecute();
    }

    #endregion
}

hwstats.unity3d.com/mobile/display.html

Наверху {Binding Path=Dat1}, внизу {Binding Path=Dt1}. Опечатка - не хватает символа a.

При запуске программы в студии в окне Output часто выводятся диагностические сообщения, и подобные ошибки там выводятся.

Рекомендую начать с чего-нибудь попроще, пусть даже клон. Сделайте клон какого-нибудь платформера или Galaxy (или что больше нравится). Это важно, потому что дальше будет слишком много времени будет уходить на сложные задачи по программированию, с которым у вас пока слабо. Когда вы сделаете вашу первую программу, дальше вам будет гораздо проще. Если вы будете хорошо развиваться, то можно попробовать сделать за 2-4 недели, и только потом идти к вашей игре, которую вы хотите делать. Получив какой-то опыт, вам будет легче понять хорошим советам по архитектуре игры.
Лично у меня есть несколько человек, с которыми я общаюсь и помогаю с программированием. Напишите в скайп, можно начать общение.

Вашу задачу можно сделать тремя способами:
1) создать метод, который будет суммировать каждый элемент списка в переменную, точнее, в поле класса.

long Result;
long Sum(List<int> intList)
{
    Result = 0;
    intList.ForEach(AddElement);
    return Result;
}

void AddElement(int i)
{
    Result += i;
}

2) Чтобы не создавать "лишнюю" функцию, необходимую только для конкретной задачи, то можно взять анонимную функцию. Анонимные функции в C# используются с помощью делегатов. Дополнительно, анонимные функции могут использовать замыкания, и нет необходимости создавать внешнее поле.

long Sum(List<int> intList)
{
    long result = 0;
    intList.ForEach(delegate(int i) { result += i; });
    return result;
}

3) Можно взять лямбду - в данном случае, это "синтаксический сахар" - упрощение создания делегата.

long Sum(List<int> intList)
{
    long result = 0;
    intList.ForEach(i => result += i);
    return result;
}

Не могу у себя проверить, у меня всё видно хорошо (у меня Win7).

Попробуйте убрать все настройки внешнего вида. Будет ли нормально видно?

<StackPanel>
    <Label Visibility="Collapsed" Content="Неверные данные авторизации" HorizontalAlignment="Center" Margin="10,7,10,0" Width="Auto" Foreground="Red"/>
    <Label Content="Логин:"/>
    <TextBox x:Name="loginTxt" TextWrapping="NoWrap"/>
    <Label Content="Пароль:"/>
    <PasswordBox x:Name="passwordTxt"/>
    <Button Content="Войти"/>
</StackPanel>

Если не изменится, то уберите атрибуты в Window.
Если заработало, то постепенно возвращайте атрибуты в элементы. Или установите общий стиль для всех элементов сразу, чтобы для всех элементов стали одинаковые стили:

<Window.Resources>
    <Style x:Key="CommonStyle" TargetType="Control">
        <Setter Property="Margin" Value="5" />
        <Setter Property="Padding" Value="5" />
        <Setter Property="FontSize" Value="16"/>
        <Setter Property="Width" Value="150"/>
    </Style>
    <Style TargetType="Label" BasedOn="{StaticResource CommonStyle}"/>
    <Style TargetType="TextBox" BasedOn="{StaticResource CommonStyle}"/>
    <Style TargetType="PasswordBox" BasedOn="{StaticResource CommonStyle}"/>
    <Style TargetType="Button" BasedOn="{StaticResource CommonStyle}"/>
</Window.Resources>

Инкапсуляция нужна не для защиты самого кода (вы правильно сказали - всё всегда можно увидеть), а для того, чтобы защитить код, использующий класс, от изменений этого класса. Есть такие два понятия - интерфейс и реализация. У любого класса должно быть назначение (и желательно - только одно назначение), и те элементы, относящиеся к назначению, делают публичным. А те элементы, которые не связаны с самой задачей и предназначены для вспомогательных функций, то это закрытые элементы, пользователю этого класса они не нужны.

Пример. Есть задача - найти корни квадратного уравнения. Основной функцией является получение корней. Обычно это решается с помощью дискриминанта, но не обязательно, есть и другие способы, поэтому, дискриминант сам по себе не нужен, ведь дискриминант - всего лишь способ решения (реализация).

Как пример, пусть будет такой класс для решения квадратного уравнения:

class KvadrUr
{
    public double A { get; set; }
    public double B { get; set; }
    public double C { get; set; }

    public bool HasRoots { get { return GetDiscr() >= 0; } }

    public KvadrUr()
    {
    }

    public KvadrUr(double a, double b, double c)
    {
        A = a;
        B = b;
        C = c;
    }

    public double[] GetRoots()
    {
        var discr = GetDiscr();
        if (discr < 0) return new[] {double.NaN, double.NaN};
        var sqrt = Math.Sqrt(discr);
        return new[]
        {
            (-B + sqrt) / (2 * A), 
            (-B - sqrt) / (2 * A)
        };
    }

    private double GetDiscr()
    {
        return B*B - 4*A*C;
    }
}

В данном классе, есть интерфейс - данные (коэффициенты) и два метода (список корней и наличие корней). А метод вычисления дискриминанта - для задачи не нужно.

А теперь представьте, что получение дискриминанта будет публичным методом. Тогда кто-нибудь возьмёт и начнёт использовать этот метод в своём коде. И если автор класса захочет и изменит реализацию на другой способ (по формуле Виета, например), то дискриминант уже будет не нужен, и метод GetDiscr() нужно будет удалить. Но в том месте, где его использовали, будет ошибка - метод GetDiscr() не существует.

Таким образом, если в классе есть точное указание, что является интерфейсом, а что реализацией, даёт коду больше возможности на изменение этого кода.

Во многих языках программирования имеется особенная возможность, связанная с интерфейсами. В C# это одноимённое понятие - interface. В данном примере хорошо бы создать такой интерфейс:

interface IRoots
{
    bool HasRoots { get; }
    double[] GetRoots();
}
class KvadrUr : IRoots
{
    // ...
}

Можно создать несколько разных классов - один считает через дискриминант, другой - через формулу Виета, третий - через выделение полного квадрата, четвёртый - кубическое уравнение, пятый - биквадратное уравнение. Но каждый из классов реализуют один и тот же интерфейс, и каждый из них может быть взаимозаменяем.

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

Можно использовать тип данных enum в записи. Enum для этого и предназначен. В базе будет использоваться число, а при получении данных из базы будет строка.
Вот стандартное решение в доке доктрины.
Если enum только один, то можно так и сделать. Но часто enum-ов много, и тогда я делаю вот такой способ:

Базовый класс:

<?php
namespace AppBundle\DBAL;

use Doctrine\DBAL\Types\Type;
use Doctrine\DBAL\Platforms\AbstractPlatform;

abstract class EnumType extends Type
{
    protected $name;

    public static $VALUES = array();

    public static function getValues()
    {
        $values = array();
        foreach (static::$VALUES as $value) $values[$value] = $value;
        return $values;
    }

    public function getSqlDeclaration(array $fieldDeclaration, AbstractPlatform $platform)
    {
        $values = array();
        foreach (static::$VALUES as $value) $values[] = "'$value'";
        return "ENUM(".implode(", ", $values).") COMMENT '(DC2Type:$this->name)'";
    }

    public function convertToPHPValue($value, AbstractPlatform $platform)
    {
        return $value;
    }

    public function convertToDatabaseValue($value, AbstractPlatform $platform)
    {
        if (!in_array($value, static::$VALUES)) {
            throw new \InvalidArgumentException("Invalid value '$value' for enum '$this->name'.");
        }
        return $value;
    }

    public function getName()
    {
        return $this->name;
    }
}

И теперь легко сделать нужный enum:

<?php
namespace AppBundle\DBAL;

class MyType extends EnumType
{
    protected $name = 'mytype';

    const FIRST = 'first';
    const SECOND  = 'second';

    public static $VALUES = array(self::FIRST, self::SECOND);
}

Ну и в настройке указать тип:

doctrine:
    dbal:
        driver:   "%database_driver%"
        host:     "%database_host%"
        port:     "%database_port%"
        dbname:   "%database_name%"
        user:     "%database_user%"
        password: "%database_password%"
        charset:  UTF8
        types:
            mytype: AppBundle\DBAL\MyType
        mapping_types:
            enum: string

Теперь можно указать его в сущности:

class MyEntity
{
    /**
     * @var integer $id
     *
     * @ORM\Column(type="integer")
     * @ORM\Id
     * @ORM\GeneratedValue(strategy="AUTO")
     */
    protected $id;
    
   // ....
    
    /**
     * @var string
     *
     * @ORM\Column(type="mytype")
     */
    protected $type;

Для чего делать отдельный класс для каждого enum-а? Для типизации значений. Например, можно было взять список значений: $types = MyType::getValues(), или проверить тип: if ($val->getType() == MyType::FIRST) {}