Wie zu emulieren eine Konsole in WPF?

Gegeben, dass Sie möchten, um emulieren eine Konsole, würde ich es so machen. Beachten Sie, dass Sie würde haben, um die Befehle und Ausgabe der Ergebnisse selbst.

Seite.xaml

<Window x:Class="ConsoleEmulation.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="MainWindow" MinHeight="350" MinWidth="525" Height="350" Width="525">
    <Grid>
        <ScrollViewer Name="Scroller" Margin="0" Background="Black">
            <StackPanel>
                <ItemsControl ItemsSource="{Binding ConsoleOutput, Mode=OneWay}">
                    <ItemsControl.ItemTemplate>
                        <DataTemplate>
                            <TextBlock Text="{Binding Path=.}" Foreground="White" FontFamily="Consolas"/>
                        </DataTemplate>
                    </ItemsControl.ItemTemplate>
                </ItemsControl>
                <TextBox Text="{Binding ConsoleInput, Mode=TwoWay}" Background="Black" Foreground="White" FontFamily="Consolas" Name="InputBlock" BorderBrush="{x:Null}" SelectionBrush="{x:Null}" />
            </StackPanel>
        </ScrollViewer>
    </Grid>
</Window>

Seite.xaml.cs

public partial class MainWindow : Window
{
    ConsoleContent dc = new ConsoleContent();

    public MainWindow()
    {
        InitializeComponent();
        DataContext = dc;
        Loaded += MainWindow_Loaded;
    }

    void MainWindow_Loaded(object sender, RoutedEventArgs e)
    {
        InputBlock.KeyDown += InputBlock_KeyDown;
        InputBlock.Focus();
    }

    void InputBlock_KeyDown(object sender, KeyEventArgs e)
    {
        if (e.Key == Key.Enter)
        {
            dc.ConsoleInput = InputBlock.Text;
            dc.RunCommand();
            InputBlock.Focus();
            Scroller.ScrollToBottom();
        }
    }
}

public class ConsoleContent : INotifyPropertyChanged
{
    string consoleInput = string.Empty;
    ObservableCollection<string> consoleOutput = new ObservableCollection<string>() { "Console Emulation Sample..." };

    public string ConsoleInput
    {
        get
        {
            return consoleInput;
        }
        set
        {
            consoleInput = value;
            OnPropertyChanged("ConsoleInput");
        }
    }

    public ObservableCollection<string> ConsoleOutput
    {
        get
        {
            return consoleOutput;
        }
        set
        {
            consoleOutput = value;
            OnPropertyChanged("ConsoleOutput");
        }
    }

    public void RunCommand()
    {
        ConsoleOutput.Add(ConsoleInput);
        //do your stuff here.
        ConsoleInput = String.Empty;
    }


    public event PropertyChangedEventHandler PropertyChanged;
    void OnPropertyChanged(string propertyName)
    {
        if (null != PropertyChanged)
            PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    }
}

Ich habe nicht es selbst getan, aber er ist einer von meinen "ich werde es tun wenn ich Zeit habe"-Projekte.
Also ich bin noch auf der Suche für eine vorhandene Implementierung 😛

Sowieso einige Gedanken:

Den applroach zu verwenden Visuals (D. H. Ellipsen, Textblöcke) ist wahrscheinlich nicht eine gute Idee.
Denken Sie nur, was zu geschehen hat, wenn Sie so wollen 200x100 Zeichen. Vielleicht sogar einen backbuffer. Halten Sie alle im Speicher + zeichnen....es wird unglaublich langsam.

Daher die bessere (oder auch rechten) Ansatz zum "selber ziehen". Da WPF ist backbuffered und die Sie nicht anzeigen möchten, die einer beliebigen bitmap die meisten Hilfspersonal Ansatz wäre es, erstellen Sie ein neues Benutzersteuerelement-und überschreiben Sie die Paint-Methode.
Sie ma lieber von Control abgeleitet, aber UserControl können Inhalte enthalten, so können Sie zeigen so etwas wie eine Verbindung-Symbol im inneren.

Architektur-Weise, würde ich vorschlagen, erstellen Sie eine dependecy Eigenschaft Puffer ( ConsoleBuffer ), das hält die Konsole Puffer-Modell. Ein anderes DP würde halten Sie die Obere linke Position Lage (long). Es bestimmt, wo um die Anzeige zu starten (während Sie einen Blick hinter). Die Konsole Modell würde ich eine Klasse, die enthält eine char[] und ein Color[] (ein-dimensional). Verwenden Sie Zeilenumbrüche und \n Zeichen zu machen-Linien (denn dies ist der Charakter einer Konsole). Dann, wenn Sie die Größe des Steuerelements wird es re-flow ohne die Puffer müssen neu zugewiesen werden.
Arbeiten Sie mit **ConsoleBuffer**s in verschiedenen Größen (für verschiedene Anzahl von Blick hinter Zeichen).

ConsoleBuffer.Write(string s) ist Ihre Methode, um Dinge zu tun.

Vielleicht ist es ratsam, halten Sie arrays von arrays char[][] zum darstellen von Linien.... aber das ist bis zu finden, während der Programmierung.